sequence_in_t TeacherBB::equivalenceQuery(const unique_ptr<DFSM>& conjecture) { _equivalenceQueryCounter++; auto tmp = _currState; auto model = FSMmodel::duplicateFSM(conjecture); if (!model->isReduced()) model->minimize(); for (state_t extraStates = 0; extraStates < _maxExtraStates; extraStates++) { auto TS = _testingMethod(model, extraStates); for (const auto& test : TS) { auto bbOut = resetAndOutputQuery(test); _outputQueryCounter--; sequence_out_t modelOut; state_t state = 0; for (const auto& input : test) { auto ns = model->getNextState(state, input); if ((ns != NULL_STATE) && (ns != WRONG_STATE)) { modelOut.emplace_back(model->getOutput(state, input)); state = ns; } else modelOut.emplace_back(WRONG_OUTPUT); } if (bbOut != modelOut) { _currState = tmp; return test; } } } _currState = tmp; return sequence_in_t(); }
bool PlaceableWindowProxy::handleMousePress(QMouseEvent *event) { if (!visible_) { return false; } if (!rect_.contains(event->pos())) { // We don't care about anything outside the rect. return false; } if (state_ != INACTIVE) { // We're already doing something, so we don't want to enter // another state. But we also don't want someone else to start // doing something, so we filter out the press. return true; } if (event->button() == Qt::LeftButton) { start_rect_ = rect_; start_point_ = event->pos(); state_ = getNextState(event->localPos()); qWarning("changing state to %d", state_); return true; } // Event if we're not doing anything, we want to present a // consistent interface that says "this region is belongs to me", so // we filter out events. return true; }
void Grammar::findStates( void ) { Symbol *startSym = getStartSymbol( true ); if ( ! startSym ) { Error::get()->add( "No rules to choose as start rule." ); return; } if ( RuleTable::get()->isOnRightSide( startSym->getName() ) ) { Error::get()->add( "The start symbol \"%s\" occurs on the " "right-hand side of a rule. This will result " "in a parser which does not work properly.", startSym->getName().c_str() ); } myCurConfigList.reset(); Rule *startRule = RuleTable::get()->findFirstRule( startSym->getName() ); while ( startRule ) { Config *tmpCfg = myCurConfigList.addWithBasis( startRule, 0 ); // All start rules have the start symbol as their left hand side // tmpCfg->addFollowSet( startSym->getName() ); tmpCfg->addFollowSet( SymbolTable::get()->getNthSymbol( 0 )->getName() ); startRule = RuleTable::get()->getNextRule( startRule ); } getNextState(); }
/* Add new entry to the table * Once a state is added here, we are the owners of the memory, so * we will destroy the States when this table is destroyed */ void MainTransitionFunction::addNewEntry(IMainState *from, MainMachineEvent event, IMainState *to) { // check if exists? ASSERT(getNextState(from, event) == 0); mTable[from].insert(std::pair<MainMachineEvent, IMainState *>(event, to)); }
le_int32 ThaiShaping::compose(const LEUnicode *input, le_int32 offset, le_int32 charCount, le_uint8 glyphSet, LEUnicode errorChar, LEUnicode *output, LEGlyphStorage &glyphStorage) { le_uint8 state = 0; le_int32 inputIndex; le_int32 outputIndex = 0; le_uint8 conState = 0xFF; le_int32 conInput = -1; le_int32 conOutput = -1; for (inputIndex = 0; inputIndex < charCount; inputIndex += 1) { LEUnicode ch = input[inputIndex + offset]; le_uint8 charClass; // Decompose SARA AM into NIKHAHIT + SARA AA if (ch == CH_SARA_AM && isLegalHere(ch, state)) { outputIndex = conOutput; state = getNextState(CH_NIKHAHIT, conState, inputIndex, glyphSet, errorChar, charClass, output, glyphStorage, outputIndex); for (int j = conInput + 1; j < inputIndex; j += 1) { ch = input[j + offset]; state = getNextState(ch, state, j, glyphSet, errorChar, charClass, output, glyphStorage, outputIndex); } ch = CH_SARA_AA; } state = getNextState(ch, state, inputIndex, glyphSet, errorChar, charClass, output, glyphStorage, outputIndex); if (charClass >= CON && charClass <= COD) { conState = state; conInput = inputIndex; conOutput = outputIndex; } } return outputIndex; }
void CloudsTransitionController::update() { if(transitioning){ transitionPercent = ofMap(ofGetElapsedTimef(), currentQueue.startTime, currentQueue.endTime, 0.0, 1.0, true); //started next state if(transitionPercent >= 1.0){ transitionPercent = 0.0; getNextState(); } } }
void Grammar::buildShifts( State *state ) { Config *cfp; // Each configuration becomes complete after it contibutes to a successor // state. Initially, all configurations are incomplete for ( cfp = state->getConfig(); cfp; cfp = cfp->getNext() ) cfp->setStatus( Config::INCOMPLETE ); // Loop through all configs of state for ( cfp = state->getConfig(); cfp; cfp = cfp->getNext() ) { if ( cfp->getStatus() == Config::COMPLETE ) continue; const Rule::RHSList &rhs = cfp->getRule()->getRHS(); if ( cfp->getDot() >= int( rhs.size() ) ) continue; myCurConfigList.reset(); // Symbol after the dot // for all configs in the state which have the symbol rhs[dot] // following it's dot, add the same config to the basis set under // construction but with the dot shifted one symbol to the right. for ( Config *bcfp = cfp; bcfp; bcfp = bcfp->getNext() ) { if ( bcfp->getStatus() == Config::COMPLETE ) continue; const Rule::RHSList &brhs = bcfp->getRule()->getRHS(); if ( bcfp->getDot() >= int( brhs.size() ) ) continue; if ( rhs[cfp->getDot()].first != brhs[bcfp->getDot()].first ) continue; bcfp->setStatus( Config::COMPLETE ); Config *cfg = myCurConfigList.addWithBasis( bcfp->getRule(), bcfp->getDot() + 1 ); cfg->addBackwardPropLink( bcfp ); } State *newstp = getNextState(); // Add shift action to reach state newstp from state on symbol... state->addAction( Action::SHIFT, rhs[cfp->getDot()].first, newstp, 0 ); } }
CharacterState *CharacterState::playState(Character *character) { /*TTODO: if(curWarmUpTime > warmUpTime && !actionDone) doAction(); if(curExecutionTime < executionTime) { return false; } else { return true; }*/ if (doAction(character)) { return getNextState(); } return this; }
int main(int argc, char* argv[]) { DDRC = 0x0f; DDRD = 0xf0; DDRB = 0xC3; PORTB = 0; PORTC = 0; PORTD = 0; serial_init(); send_string_serial("Starting up...\n"); _delay_ms(500); speed1 = 4000; speed2 = 4000; speed3 = 4000; speed4 = 1250; counter1 = 1; counter2 = 1; counter3 = 1; counter4 = 1; needState1 = FALSE; needState2 = FALSE; needState3 = FALSE; movingForward1 = FALSE; movingForward2 = FALSE; movingForward3 = FALSE; currentState1 = 0; currentState2 = 0; currentState3 = 0; motorState1 = getMotorState(currentState1); motorState2 = getMotorState(currentState2) << 4; unsigned char state = getMotorState(currentState3); motorState3 = ((state & 0x0C) << 4) | (state & 0x03); setupTimers(); char index = 0; int speeds[3]; char* buffer = (char*) speeds; while (1) { if (UCSRA & (1<<RXC)) { buffer[index++] = UDR; if (index == 6) { // do something with the buffer setSpeed1(speeds[0]); setSpeed2(speeds[1]); setSpeed3(speeds[2]); index = 0; send_string_serial("Received full message\n\r"); } } checkSerialSend(); if (needState1) { currentState1 = getNextState(currentState1, movingForward1); motorState1 = getMotorState(currentState1); needState1 = FALSE; } if (needState2) { currentState2 = getNextState(currentState2, movingForward2); motorState2 = getMotorState(currentState2) << 4; needState2 = FALSE; } if (needState3) { currentState3 = getNextState(currentState3, movingForward3); state = getMotorState(currentState3); motorState3 = ((state & 0x0C) << 4) | (state & 0x03); needState3 = FALSE; } /* if (needsNewSpeed) { currentSpeedIndex = (currentSpeedIndex + 1); if (currentSpeedIndex == 0x40) { currentSpeedIndex = 0; send_string_serial("Loop...\n"); } setSpeed1(speed[0][currentSpeedIndex]); setSpeed2(speed[1][currentSpeedIndex]); setSpeed3(speed[2][currentSpeedIndex]); needsNewSpeed = FALSE; } */ } return 0; }
void CloudsTransitionController::startTransition(){ transitioning = true; getNextState(); update(); }
int main() { int i; //for 'for' loops //level to stop splitting int L, L1; //this means each state has L leaves resulting from k splits cout << "Number of splits? "; cin >> L1; L = L1 + 1; //number of splits int k; //number of distinct states or Catalan number long double Csplit[L]; //total number of possible paths to reach any state at level L unsigned long int totalPaths[L]; //container for states States currStates, nextStates; States::iterator iterCurrStates; State currState, nextState; State::iterator iterCurrState; // a map for the Catalan Coefficients typedef map<State, int, LexicoSorting<State> > StatesMap; StatesMap StateCount; StatesMap::iterator iterStateCount; std::pair<StatesMap::iterator, bool> boolStateCount; //state space at 0 split State state0; state0.push_back(0); StateCount.insert(make_pair(state0,1)); Csplit[0]=1; totalPaths[0]=1; //ofstream to output CatalanCoefficient and CatalanFrequencies to .txt. ofstream oss; clock_t start, end; double timeTaken; //Loop to get Catalan coefficients and frequencies using L-R leaf-depth encoding for (k=1; k < L; k++) //for a given number of splits { //Set up string for filename to output the Catalan coefficients and frequencies string fileNameCC, fileNameCF; fileNameCC = "CatalanCoefficientSplit"; fileNameCF = "CatalanFrequencySplit"; std::ostringstream stm1; //convert k to std::ostringstream start=clock(); //record the time taken to get the Catalan coefficient and frequencies //Get number of nodes, Catalan number and total possible paths for each split Csplit[k] = Catalan(k); totalPaths[k] = factorial(k); cout << "========================================" << endl; cout << "At " << k << " splits:" << endl; cout << Csplit[k] << " distinct states " << "\t" << totalPaths[k] << " possible paths " << endl; //Set up an empty map to store new states StatesMap newStateCount; StatesMap::iterator iterNewStateCount; std::pair<StatesMap::iterator, bool> boolNewStateCount; //for each state in current states map, StateCount for (iterStateCount=StateCount.begin(); iterStateCount != StateCount.end(); iterStateCount++) { currState = iterStateCount->first; //current state in current states map //cout << "Current state:" << getStringState(currState) << endl; //for each node in current state for(int node = 0; node < currState.size(); node++) { //get state for each node in current state nextState = getNextState(currState, node); //cout << "Next state: " << getStringState(nextState) << endl; //insert the new state into newStateMap boolNewStateCount = newStateCount.insert(make_pair(nextState, 1)); //Check if insertion is successful - a unique set will render a successful insertion. if(!(boolNewStateCount.second)) //if state is not unique { //increment by the Catalan coefficient of the current state producing this next state newStateCount[nextState] += StateCount[currState]; //cout << "this state already exist" << endl; } //end of "non-unique state" else { //set the count of this next state as the Catalan coefficient of current state newStateCount[nextState] = StateCount[currState]; //cout << "this is a unique state" << endl; } //end of "unique state" } //end of looping over node in current state } //end of looping through all Ck states in current states map cout << "There are " << newStateCount.size() << endl; //cout << " distinct states with the following breakdown:" << endl; //Catalan Coefficients //Output states with corresponding counts in .txt. stm1 << k; //name file according to the number of splits k fileNameCC += stm1.str(); fileNameCC += ".txt"; oss.open(fileNameCC.c_str()); //set up a vector for the number of paths leading to each state in newStateCount vector<int> StatePathVec; vector<int>::iterator iterStatePathVec; //set up a map for the frequencies corresponding to state paths map<int, int, less<int> > StateFreqMap; map<int, int, less<int> >::iterator iterStateFreqMap; std::pair<map<int, int, less<int> >::iterator, bool> boolStateFreqMap; int Path; for(iterNewStateCount=newStateCount.begin(); iterNewStateCount != newStateCount.end(); iterNewStateCount++) { State thisState = iterNewStateCount->first; //cout << getStringState(thisState) << "\t\t" << iterNewStateCount->second << endl; oss << getStringState(thisState) << "\t" << (iterNewStateCount->second)<< "\n"; //Find frequencies for state paths Path = iterNewStateCount->second; boolStateFreqMap = StateFreqMap.insert(make_pair(Path, 1)); if (!(boolStateFreqMap.second)) //if there is more than one state with Path { StateFreqMap[Path] += 1; } } //close ostream for CatalanCoefficientSplitk.txt oss << flush; oss.close(); cout << "State counts output to " << fileNameCC << endl; //output Catalan Frequencies to.txt fileNameCF += stm1.str(); fileNameCF += ".txt"; oss.open(fileNameCF.c_str()); oss << "Paths" << "\t\t" << "States" << "\n"; //Output to .txt for (iterStateFreqMap = StateFreqMap.begin(); iterStateFreqMap != StateFreqMap.end(); iterStateFreqMap++) { //cout << "There are " << iterStateFreqMap->second << " states with " // << iterStateFreqMap->first << " paths." << endl; oss << iterStateFreqMap->first << "\t\t" << iterStateFreqMap->second << "\n"; } oss << flush; oss.close(); cout << "State frequencies output to " << fileNameCF << endl; //Empty current states map StateCount.clear(); if ( StateCount.empty()) { //set nextStateCount map to be StateCount to continue loop //cout << "space emptied" << endl; StateCount = newStateCount; } else { cout << "space not emptied. Should not proceed." << endl; break; } end=clock(); timeTaken = static_cast<double>(end-start)/CLOCKS_PER_SEC; cout << "Computing time : " <<timeTaken<< " s." << endl; } return 0; }
status_t OMXCameraAdapter::doAutoFocus() { status_t ret = NO_ERROR; OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focusControl; OMX_PARAM_FOCUSSTATUSTYPE focusStatus; OMX_CONFIG_BOOLEANTYPE bOMX; nsecs_t timeout = 0; LOG_FUNCTION_NAME; if ( OMX_StateInvalid == mComponentState ) { CAMHAL_LOGEA("OMX component in Invalid state"); returnFocusStatus(false); return -EINVAL; } if ( OMX_StateExecuting != mComponentState ) { CAMHAL_LOGEA("OMX component not in executing state"); returnFocusStatus(false); return NO_ERROR; } if( ((AF_ACTIVE & getState()) != AF_ACTIVE) && ((AF_ACTIVE & getNextState()) != AF_ACTIVE) ) { CAMHAL_LOGDA("Auto focus got canceled before doAutoFocus could be called"); return NO_ERROR; } OMX_INIT_STRUCT_PTR (&focusStatus, OMX_PARAM_FOCUSSTATUSTYPE); // If the app calls autoFocus, the camera will stop sending face callbacks. pauseFaceDetection(true); // This is needed for applying FOCUS_REGION correctly if ( (!mFocusAreas.isEmpty()) && (!mFocusAreas.itemAt(0)->isZeroArea())) { //Disable face priority setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false); //Enable region algorithm priority setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true); } OMX_INIT_STRUCT_PTR (&focusControl, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE); focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) mParameters3A.Focus; if (mParameters3A.FocusLock) { // this basically means user never called cancelAutoFocus after a scan... // if this is the case we need to unlock AF to ensure we will do a scan if (set3ALock(mUserSetExpLock, mUserSetWbLock, OMX_FALSE) != NO_ERROR) { CAMHAL_LOGEA("Error Unlocking 3A locks"); } else { CAMHAL_LOGDA("AE/AWB unlocked successfully"); } } else if ( mParameters3A.Focus == OMX_IMAGE_FocusControlAuto ) { // In case we have CAF running we should first check the AF status. // If it has managed to lock, then do as usual and return status // immediately. ret = checkFocus(&focusStatus); if ( NO_ERROR != ret ) { CAMHAL_LOGEB("Focus status check failed 0x%x!", ret); return ret; } else { CAMHAL_LOGDB("Focus status check 0x%x!", focusStatus.eFocusStatus); } } if ( (focusControl.eFocusControl == OMX_IMAGE_FocusControlAuto && ( focusStatus.eFocusStatus == OMX_FocusStatusRequest || focusStatus.eFocusStatus == OMX_FocusStatusUnableToReach || focusStatus.eFocusStatus == OMX_FocusStatusLost ) ) || (mParameters3A.Focus != (OMX_IMAGE_FOCUSCONTROLTYPE)OMX_IMAGE_FocusControlAuto) ) { OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE); bOMX.bEnabled = OMX_TRUE; //Enable focus scanning eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_TI_IndexConfigAutofocusEnable, &bOMX); // force AF, Ducati will take care of whether CAF // or AF will be performed, depending on light conditions if ( focusControl.eFocusControl == OMX_IMAGE_FocusControlAuto && ( focusStatus.eFocusStatus == OMX_FocusStatusUnableToReach || focusStatus.eFocusStatus == OMX_FocusStatusLost ) ) { focusControl.eFocusControl = OMX_IMAGE_FocusControlAutoLock; } if ( focusControl.eFocusControl != OMX_IMAGE_FocusControlAuto ) { eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focusControl); } if ( OMX_ErrorNone != eError ) { CAMHAL_LOGEB("Error while starting focus 0x%x", eError); return INVALID_OPERATION; } else { CAMHAL_LOGDA("Autofocus started successfully"); } // configure focus timeout based on capture mode timeout = (mCapMode == VIDEO_MODE) ? ( ( nsecs_t ) AF_VIDEO_CALLBACK_TIMEOUT * 1000 ) : ( ( nsecs_t ) AF_IMAGE_CALLBACK_TIMEOUT * 1000 ); { Mutex::Autolock lock(mDoAFMutex); ret = mDoAFCond.waitRelative(mDoAFMutex, timeout); } //If somethiing bad happened while we wait if (mComponentState == OMX_StateInvalid) { CAMHAL_LOGEA("Invalid State after Auto Focus Exitting!!!"); return -EINVAL; } if(ret != NO_ERROR) { CAMHAL_LOGEA("Autofocus callback timeout expired"); ret = returnFocusStatus(true); } else { ret = returnFocusStatus(false); } } else { // Focus mode in continuous if ( NO_ERROR == ret ) { ret = returnFocusStatus(true); mPending3Asettings |= SetFocus; } } LOG_FUNCTION_NAME_EXIT; return ret; }
void LitResDataParser::endElementHandler(const char *tag) { processState(tag, true, 0); myState = getNextState(tag, true); myBuffer.clear(); }
void LitResDataParser::startElementHandler(const char *tag, const char **attributes) { processState(tag, false, attributes); myState = getNextState(tag, false); myBuffer.clear(); }
ArrowMap::ArrowMap(const std::string &networkFilePath) { //Unpack information from file numNodes = 0; unsigned int *ancLengths; unsigned int **structure; unsigned int *lutLengths; bool **nodeLUTs; char buf[2]; std::ifstream networkFile; networkFile.open(networkFilePath.c_str(), std::ios::binary); if (!networkFile.is_open()) throw "File not found."; networkFile.read(buf, 2); numNodes = buf[0] << 8 | buf[1]; ancLengths = new unsigned int[numNodes]; structure = new unsigned int*[numNodes]; nodeLUTs = new bool*[numNodes]; lutLengths = new unsigned int[numNodes]; for (int i = 0; i < numNodes; i++) { networkFile.read(buf, 1); ancLengths[i] = buf[0]; //networkFile.read((char*)&ancLengths[i], 1); structure[i] = new unsigned int[ancLengths[i]]; for (int j = 0; j < ancLengths[i]; j++) { networkFile.read(buf, 2); structure[i][j] = buf[0] << 8 | buf[1]; } lutLengths[i] = 1 << ancLengths[i]; nodeLUTs[i] = new bool[lutLengths[i]]; for (int j = 0; j < lutLengths[i]; j++) { if (j % 8 == 0) networkFile.read(buf, 1); nodeLUTs[i][j] = buf[0] >> (7-j%8) & 1; } } /*std::cout << numNodes << "\n\n"; for (int i = 0; i < numNodes; i++) { std::cout << ancLengths[i] << "\n"; for (int j = 0; j < ancLengths[i]; j++) std::cout << structure[i][j] << "\n"; std::cout << lutLengths[i] << "\n"; for (int j = 0; j < lutLengths[i]; j++) std::cout << nodeLUTs[i][j] << " "; std::cout << "\n\n"; }*/ //Compute entire state space graph bool *states = new bool[numNodes]; graphSize = 1 << numNodes; graph = new state[graphSize]; for (unsigned int i = 0; i < graphSize; i++) { graph[i].attractor = false; for (int j = 0; j < numNodes; j++) states[numNodes - j - 1] = i >> j & 1; graph[i].id = 0; for (int j = 0; j < numNodes; j++) { int n = 0; for (int k = 0; k < ancLengths[j]; k++) n |= states[structure[j][k]] << k; graph[i].id <<= 1; graph[i].id |= nodeLUTs[j][n]; } } delete [] states; for (int i = 0; i < numNodes; i++) { delete [] structure[i]; delete [] nodeLUTs[i]; } delete [] structure; delete [] nodeLUTs; delete [] ancLengths; delete [] lutLengths; //Determine which states are in attractors bool *done = new bool[graphSize]; //bool *flipMap = new bool[graphSize]; //bool lastFlip = false; unsigned int numRem = graphSize; unsigned int state = 0; //unsigned int numOn = 0; memset(done, false, graphSize * sizeof(bool)); //memset(flipMap, false, graphSize * sizeof(bool)); while (numRem > 0) { //Fall into attractor for (int i = 0; i < 100; i++) //DEBUG: Fix this later!!! { if (done[state] == false) numRem--; done[state] = true; state = getNextState(state); } /*while (true) { done[state] = true; numRem--; flipMap[state] = !flipMap[state]; if (lastFlip != flipMap[state]) break; lastFlip = flipMap[state]; state = getNextState(state); //std::cout << state << std::endl; //std::cout << getNextState(state) << std::endl; }*/ /*while (!done[state]) { done[state] = true; numRem--; state = getNextState(state); std::cout << state << std::endl; std::cout << getNextState(state) << std::endl; }*/ //Run around attractor once while(!graph[state].attractor) { graph[state].attractor = true; state = getNextState(state); } for (state = 0; state < graphSize-1 && done[state]; state++); //std::cout << "\n"; } delete [] done; //delete [] flipMap; }
bool PlaceableWindowProxy::handleMouseMove(QMouseEvent *event) { if (!visible_) { return false; } if (state_ == INACTIVE) { if (!rect_.contains(event->localPos())) { if (has_cursor_) { QApplication::restoreOverrideCursor(); has_cursor_ = false; } return false; } // The mouse cursor is over the rect, so we're going to change the // cursor to indicate the state the user would enter by clicking. Qt::CursorShape shape; switch(getNextState(event->localPos())) { case MOVE_TOP_LEFT: case MOVE_BOTTOM_RIGHT: shape = Qt::SizeFDiagCursor; break; case MOVE_TOP_RIGHT: case MOVE_BOTTOM_LEFT: shape = Qt::SizeBDiagCursor; break; default: shape = Qt::SizeAllCursor; } if (has_cursor_) { QApplication::changeOverrideCursor(QCursor(shape)); } else { QApplication::setOverrideCursor(QCursor(shape)); has_cursor_ = true; } return true; } QPointF dp = event->localPos() - start_point_; // todo: enforce minimum size & constrain aspect ratio for resizes. if (state_ == MOVE_ALL) { rect_ = start_rect_.translated(dp); } else if (state_ == MOVE_TOP_LEFT) { rect_= resizeHelper(start_rect_, start_rect_.bottomRight(), start_rect_.topLeft(), event->localPos()); rect_.moveBottomRight(start_rect_.bottomRight()); } else if (state_ == MOVE_BOTTOM_LEFT) { rect_= resizeHelper(start_rect_, start_rect_.topRight(), start_rect_.bottomLeft(), event->localPos()); rect_.moveTopRight(start_rect_.topRight()); } else if (state_ == MOVE_BOTTOM_RIGHT) { rect_= resizeHelper(start_rect_, start_rect_.topLeft(), start_rect_.bottomRight(), event->localPos()); rect_.moveTopLeft(start_rect_.topLeft()); } else if (state_ == MOVE_TOP_RIGHT) { rect_= resizeHelper(start_rect_, start_rect_.bottomLeft(), start_rect_.topRight(), event->localPos()); rect_.moveBottomLeft(start_rect_.bottomLeft()); } else { qWarning("Unhandled state in PlaceableWindowProxy: %d", state_); } return true; }
//===------------------------------===// // Get the next terminal state // Handle error input //===------------------------------===// int Scanner::getNextTerminalState() { int current_state = 0; char current_char; do { current_char = getCurrentChar(); // Only add to lexeme one double quote that // immediately follows a double quote if ( current_char != '"' || current_state == 10 ) current_lexeme = current_lexeme + current_char; // Check whether we found a comment string bracket_comment = current_lexeme.substr( 0, 1 ); string slash_comment = current_lexeme.substr( 0, 2 ); if ( ( bracket_comment == "{" && current_char == '}' ) || ( slash_comment == "//" && current_char == '\n' ) ) current_lexeme = ""; // Erase all whitespaces if the whitespace // is the only thing in current lexeme if ( isspace( current_char ) ) if ( current_lexeme.length() == 1 ) current_lexeme.erase( current_lexeme.length() - 1, 1 ); // Mark beginning line and column of lexeme if ( current_lexeme.length() == 1 ) { token_line = line_number; token_column = column_number; } // Get the next state current_state = getNextState( current_state, current_char ); // Advance to the next character // for use in the subsequent loop advance(); switch ( current_state ) { case IDENT_T: return current_state; case SINGLE0_T: return current_state; case INTEGER_T: return current_state; case SETEQUAL_T: return current_state; case ISEQUAL_ST: return current_state; case NOTEQUAL_ST: return current_state; case LESSER_ST: return current_state; case LESSEQUAL_ST: return current_state; case GREATER_ST: return current_state; case GREQUAL_ST: return current_state; case ADDITION_ST: return current_state; case SUBTRACT_ST: return current_state; case ASTERISK_ST: return current_state; case COLON_T: return current_state; case SEMICOLON_T: return current_state; case COMMA_T: return current_state; case PERIOD_T: return current_state; case STRINGCONST_T: return current_state; case CRERRORCONST_T: return current_state; case EOFERRORCONST_T: return current_state; case LEFTPARENTH_T: return current_state; case RIGHTPARENTH_T: return current_state; case SLASHERROR_T: return current_state; case BRACKETERROR_T: return current_state; case EOF_T: return current_state; case OTHERERROR: return current_state; } } while ( 1 ); // Keep getting the next state until // found terminal state of the current lexeme }
ActionChain* ActionFactory::atack(const model::World& w, const model::Trooper& trooper, std::list<Tactician::Tactic> tactics, bool isFirstMove){ ActionChain* res = NULL; const model::Trooper* enemyToAttack = NULL; const std::vector<model::Trooper>& troopers = w.getTroopers(); int curPoints = trooper.getActionPoints(); int enemyHealth = 0; bool headShot = false; if (tactics.end() != std::find(tactics.begin(), tactics.end(), Tactician::ATTACK)){ std::vector<model::Trooper>::const_iterator it = troopers.begin(); float min = 1 << 20; for (; it != troopers.end(); ++it){ if (!(*it).isTeammate()){ int health = it->getHitpoints(); if (w.isVisible(trooper.getShootingRange(), trooper.getX(), trooper.getY(), trooper.getStance(), it->getX(), it->getY(), it->getStance())) if (health <= (curPoints / trooper.getShootCost()) * trooperDamage(trooper, trooper.getStance())){ enemyToAttack = &(*it); headShot = true; break; } float d = trooper.getDistanceTo(*it); if (d <= min ){ min = d; enemyToAttack = &(*it); enemyHealth = health; } } } } do{ if (enemyToAttack == NULL) break; if (!headShot && trooper.getActionPoints() <= 4 && trooper.getActionPoints() > 1 && trooper.getStance() != model::PRONE && !w.isVisible(trooper.getShootingRange(), enemyToAttack->getX(), enemyToAttack->getY(), enemyToAttack->getStance(), trooper.getX(), trooper.getY(), getNextState(trooper, false))) { res = new ActionChain(); std::list<ActionChunk> c; ActionChunk chunk(model::LOWER_STANCE, Vector2d(-1, -1)); c.push_back(chunk); res->executor = &trooper; res->chain = c; break; } if (!headShot && trooper.isHoldingGrenade() && trooper.getDistanceTo(*enemyToAttack) <= 5 && trooper.getActionPoints() >= 8){ res = new ActionChain(); std::list<ActionChunk> c; ActionChunk chunk(model::THROW_GRENADE, Vector2d(enemyToAttack->getX(), enemyToAttack->getY())); c.push_back(chunk); res->executor = &trooper; res->chain = c; break; } if (w.isVisible(trooper.getShootingRange(), trooper.getX(), trooper.getY(), trooper.getStance(), enemyToAttack->getX(), enemyToAttack->getY(), enemyToAttack->getStance())){ res = new ActionChain(); if (enemyHealth > (curPoints / trooper.getShootCost()) * trooperDamage(trooper, trooper.getStance()) && trooper.getStance() != model::PRONE && w.isVisible(trooper.getShootingRange(), trooper.getX(), trooper.getY(), getNextState(trooper, false), enemyToAttack->getX(), enemyToAttack->getY(), enemyToAttack->getStance())){ std::list<ActionChunk> c; ActionChunk chunk(model::LOWER_STANCE, Vector2d(-1, -1)); c.push_back(chunk); res->executor = &trooper; res->chain = c; }else{ std::list<ActionChunk> c; ActionChunk chunk(model::SHOOT, Vector2d(enemyToAttack->getX(), enemyToAttack->getY())); c.push_back(chunk); res->executor = &trooper; res->chain = c; } }else{//invisible //try to stand up first if (trooper.getStance() != model::STANDING && !w.isVisible(trooper.getShootingRange(), trooper.getX(), trooper.getY(), trooper.getStance(), enemyToAttack->getX(), enemyToAttack->getY(), enemyToAttack->getStance())){ res = new ActionChain(); std::list<ActionChunk> c; ActionChunk chunk(model::RAISE_STANCE, Vector2d(-1, -1)); c.push_back(chunk); res->executor = &trooper; res->chain = c; break; } //try to move Vector2d dst = findBestPositionToAttack(w, trooper, *enemyToAttack); if (dst == Vector2d(-1,-1)) break; PathFinder pf; std::list<Vector2d> path = pf.calcOptimalPath(w, Vector2d(trooper.getX(), trooper.getY()), dst); if (path.empty())//overchecking break; path.pop_front(); res = new ActionChain(); std::list<ActionChunk> c; std::list<Vector2d>::iterator it2 = path.begin(); for (; it2 != path.end(); ++it2){ ActionChunk chunk(model::MOVE, *it2); c.push_back(chunk); } res->executor = &trooper; res->chain = c; break; } }while(0); return res; }