JoyStick::~JoyStick() { for(std::vector<AnalogAxisState*>::iterator it = axis.begin(); it != axis.end(); ++it) { removeState(*it); delete(*it); } axis.clear(); for(std::vector<DigitalState*>::iterator it = buttons.begin(); it != buttons.end(); ++it) { removeState(*it); delete(*it); } buttons.clear(); }
/// /// \brief UpdateSnakePos Offsets the snake, sets up the state of the head /// and moves the rest of the body /// \param _head /// \param io_tail /// \param _dir The direction the head should move /// void updateSnakePos(Node * _head, Node ** io_tail, Move _dir) { if(_head != NULL && *io_tail!=NULL) { if(_dir != NOTMOVING) { const int segmentRadius = _head->pos.h; const int moveOffset = segmentRadius/4; Node newNeck = *_head; // Keep track of the head's old position addState(_head, MOVING); moveSprite(_dir, &_head->pos, moveOffset); // Store the last move direction so the head // points in the right direction when there is no input _head->idleDirection = _dir; shiftSnakeBody(_head, io_tail, &newNeck.pos); } else { removeState(_head, MOVING); } } }
void undo() const override { auto& scenar = m_scenarioPath.find(); auto& globalEvent = scenar.event(m_destinationEventId); Deserializer<DataStream> s{m_serializedEvent}; auto recreatedEvent = new EventModel{s, &scenar}; auto states_in_event = recreatedEvent->states(); // we remove and re-add states in recreated event // to ensure correct parentship between elements. for(auto stateId : states_in_event) { recreatedEvent->removeState(stateId); globalEvent.removeState(stateId); } for(auto stateId : states_in_event) { recreatedEvent->addState(stateId); scenar.states.at(stateId).setEventId(m_movingEventId); } scenar.events.add(recreatedEvent); if(recreatedEvent->timeNode() != globalEvent.timeNode()) { auto& tn = scenar.timeNode(globalEvent.timeNode()); tn.addEvent(m_movingEventId); m_mergeTimeNodesCommand->undo(); } updateEventExtent(m_destinationEventId, scenar); }
void StateManager::popState(const std::string &n) { if (canChangeState() && !states.empty()) { if (stateObjects[(*(states.top())).name]) stateObjects[(*(states.top())).name]->removeState(); //states.top()->eraseRenderObjects(); std::string n = (*(states.top())).name; removeState(n); delete states.top(); if (core->getNestedMains()==1) core->clearGarbage(); // HACK: Fugly, fugly code for (int i = 0; i < 2; i++) { std::stack<StateData*>copy; copy = states; while (!states.empty()) states.pop(); while (!copy.empty()) { if (copy.top()->name != n) states.push(copy.top()); copy.pop(); } } stateChangeFlag = true; } }
void TestProtocol::stopReceiving() { if(! hasState(Receiving) ) { // TODO: report warning: already stopped return; } disableTimer(dataTimer); removeState(Receiving); }
void StateManager::processRequests() { for (auto it = m_toRemove.begin(); it != m_toRemove.end(); it++) { removeState(*it); m_toRemove.erase(it); } }
Keyboard::~Keyboard() { for (unsigned int i = 0; i < 256; ++i) { removeState(mKeys[i]); delete mKeys[i]; mKeys[i] = 0; } }
void TestProtocol::checkADC() { addState(ADCWaiting); checkADCTimer->setSingleShot(true); connect(checkADCTimer, &QTimer::timeout, [=]() { addState(ADCReady); removeState(ADCWaiting); emit checkedADC(true); }); checkADCTimer->start(1100); }
void DRDirectionalLight::enableDebugShape( bool enable ) { if ( enable ) { addState( *m_material ); } else { removeState( *m_material ); } }
void Automaton::onExecute() { std::list<Smointer<State>>::iterator it; for(it = m_stateList.begin(); it != m_stateList.end(); it++) { if((*it)->isReady()) m_stateList.push_back((*it)->getTransition()); if((*it)->isPopable()) removeState(*it); else (*it)->onUpdate(); } }
void TestProtocol::checkGPS() { addState(GPSWaiting); checkGPSTimer->setSingleShot(true); connect(checkGPSTimer, &QTimer::timeout, [=]() { addState(GPSReady); addState(GPSHasTime); addState(GPSHasPos); removeState(GPSWaiting); emit positionAvailable(DEFAULT_LATITUDE, DEFAULT_LONGITUDE, DEFAULT_ALTITUDE); emit checkedGPS(true); }); checkGPSTimer->start(2000); }
void AddCharacterDialog::addState(const QString& state, const QString& imagePath) { QTreeWidgetItem *item = new QTreeWidgetItem(mUi.statusTreeWidget); item->setText(0, state); item->setIcon(0, QIcon(imagePath)); item->setData(0, Qt::UserRole, imagePath); item->setFlags(item->flags() | Qt::ItemIsEditable); QPushButton *removeBtn = new QPushButton(QIcon(":/media/delete.png"), "", mUi.statusTreeWidget); removeBtn->setFlat(true); connect(removeBtn, SIGNAL(clicked()), this, SLOT(removeState())); mUi.statusTreeWidget->setItemWidget(item, 1, removeBtn); for(int i=0; i < mUi.statusTreeWidget->columnCount(); i++) mUi.statusTreeWidget->resizeColumnToContents(i); }
void StateManager::popState() { if (canChangeState() && !states.empty()) { if (stateObjects[(*(states.top())).name]) stateObjects[(*(states.top())).name]->removeState(); //states.top()->eraseRenderObjects(); std::string n = (*(states.top())).name; removeState(n); delete states.top(); if (core->getNestedMains()==1) core->clearGarbage(); states.pop(); stateChangeFlag = true; } }
Node *createSnake(Node *_head, int _count, Node *_body) { Node *root = createSegment(_head); setState(root, HEAD); setState(_body, BODY); const int StripeSize = 3; int counter = 0; Node *listptr = root; if(_count > 0) { //Create and position the body segments for(int i = 0; i < _count; ++i) { if(listptr!=NULL) { // Set the initial strip pattern on the snake // and change the starting frame for a ripple effect counter++; if(counter <= StripeSize) { addState(_body, ALT); _body->anim.currentFrame = 1; } else if(counter < (StripeSize*2)) { removeState(_body, ALT); _body->anim.currentFrame = 0; } else { counter = 0; } insertAfterSegment(listptr, createSegment(_body), false); updateSnakePos(root, &listptr->next, RIGHT); listptr = getLastSegment(root); } } } return root; }
/*! \internal */ bool QtStateGroup::event(QEvent *event) { if (event->type() == QEvent::ChildAdded) { QChildEvent *childEvent = static_cast<QChildEvent *>(event); if (QtState *state = qobject_cast<QtState *>(childEvent->child())) { if (state->group() != this) addState(state); } } else if (event->type() == QEvent::ChildRemoved) { QChildEvent *childEvent = static_cast<QChildEvent *>(event); if (QtState *state = qobject_cast<QtState *>(childEvent->child())) { if (state->group() == this) removeState(state); } } return QObject::event(event); }
void SFMLApp::decipherMessage(SFMLStateMessage* message) { switch(message->getType()) { case SFMLStateMessage::Type::None: { break; } case SFMLStateMessage::Type::Close: { OnClose(); break; } case SFMLStateMessage::Type::Resize: { SFMLStateMessage_Resize* msg = dynamic_cast<SFMLStateMessage_Resize*>(message); OnResize(msg->m_width, msg->m_height); break; } case SFMLStateMessage::Type::ChangeState: { SFMLStateMessage_ChangeState* msg = dynamic_cast<SFMLStateMessage_ChangeState*>(message); changeState(msg->m_stateID, msg->m_stateInfo.get()); break; } case SFMLStateMessage::Type::PushState: { SFMLStateMessage_PushState* msg = dynamic_cast<SFMLStateMessage_PushState*>(message); pushState(msg->m_stateID, msg->m_stateInfo.get()); break; } case SFMLStateMessage::Type::PopState: { SFMLStateMessage_PopState* msg = dynamic_cast<SFMLStateMessage_PopState*>(message); popState(msg->m_stateInfo.get()); break; } case SFMLStateMessage::Type::RemoveState: { SFMLStateMessage_RemoveState* msg = dynamic_cast<SFMLStateMessage_RemoveState*>(message); removeState(msg->m_stateID); break; } } }
void shiftSnakeBody(Node *_head, Node **io_tail, SDL_Rect *_oldHeadPos) { if(_head == NULL || io_tail == NULL) { return; } // We must only be dealing with 2 segments, // so don't attempt to rearrange the linked segments if((*io_tail)->prev == _head) { (*io_tail)->pos = *_oldHeadPos; return; } Node *head = _head; Node *neck = _head->next; Node *newneck = *io_tail; newneck->pos = *_oldHeadPos; // The new tail will be the second to last segment *io_tail = (*io_tail)->prev; // Remove the swallow effect when it reaches the tail if(getState(*io_tail, EATING)) { removeState(*io_tail, EATING); } unlinkNextSegment(newneck->prev); linkSegments(head, newneck); linkSegments(newneck, neck); }
int emf_shootIntruder(int key) { static int status = 0; unsigned int sw; static BlobTracker *bt; int blobfound; double bx, by; double error; double resp; CvPoint center; if (key == 0) { status = 0; bt = intruder; is.hdPanAngle = 90; send_command(SERVO_PAN, (byte)((int)is.hdPanAngle)); } if (status == 0) { /*sendCommand(LTMTR_SDIR, 1, 0); sendCommand(RTMTR_SDIR, 1, 0); sendCommand(DIFF_DRV, is.ltMotorVal=150, is.rtMotorVal=165);*/ int i; for (i=0; i<5; ++i) { while (1) { frame = cvQueryFrame(capture); trackBlobs(bt, frame, 0); blobfound = bt->blobs->trackable; center = bt->blobs->center; if (blobfound) { bx = ((double)center.x/(double)fsize.width)*100.0; by = ((double)center.y/(double)fsize.height)*100.0; printf("pos bx=%g, by=%g\n", bx, by); error = bx-50.0; printf("SHOOT PAN ERR= %g.\n", error); if ((error>0&&error<10.0) || (error<0&&error>-10.0)) break; //resp = getPidRespVerb(&driveMtrPID, error, fp, "DriveMtr"); resp = (double)error*0.2; is.hdPanAngle += resp; if (is.hdPanAngle < MAX_SERVO_PAN_LEFT) is.hdPanAngle = MAX_SERVO_PAN_LEFT; else if (is.hdPanAngle > MAX_SERVO_PAN_RIGHT) is.hdPanAngle = MAX_SERVO_PAN_RIGHT; send_command(SERVO_PAN, (byte)((int)is.hdPanAngle)); } else { status = 1; return 1; } } printf("in laser_shoot: %d.\n", i); send_command(LASER_CMD, LASER_ON); //sleep(2); sw = getTickCount(); while ((getTickCount()-sw)<2000) frame = cvQueryFrame(capture); send_command(LASER_CMD, LASER_OFF); sw = getTickCount(); while ((getTickCount()-sw)<2000) frame = cvQueryFrame(capture); trackBlobs(bt, frame, 0); if (!bt->blobs->trackable) break; } if (bt->blobs->trackable) status = 2; else status = 1; } if (status == 1) { sw = getTickCount(); while ((getTickCount()-sw)<5000) { frame = cvQueryFrame(capture); } //sendCommand(BUZ_TOGGLE, 0, 0); //++status; removeState(&is, "intruder_near"); printf("Starting again.\n"); } if (status == 2) { int status = 0; //sendCommand(BUZ_TOGGLE, 0, 0); send_command(ROBOT_STATUS, SET_LED(status, 3)); /*sw = getTickCount(); while ((getTickCount()-sw)<1000) { frame = cvQueryFrame(capture); } //sendCommand(BUZ_TOGGLE, 0, 0); //++status;*/ removeState(&is, "intruder_near"); //removeState(&is, "gp_near"); addState(&is, "done_shooting"); printf("Finished\n"); } return 1; }
int emf_movetoBlob(int key) { static int status=0; unsigned int sw; int blobfound; double bx, by; double error; double resp; CvPoint center; static double maxTiltAngle; static BlobTracker *bt; static PID driveMtrPID = {5.0, 0.1, 0.01, 0.0, 0.0, 0.0}; //static PID driveMtrPID = {1.0, 0.1, 0.05, 0.0, 0.0, 0.0}; // static PID driveMtrPID = {3.0, 2.0, 1.0, 0.0, 0.0, 0.0}; static PID tiltSrvPID = {0.05, 0.035, 0.001, 0.0, 0.0, 0.0}; static FILE *fp; if (key == 0) { status = 0; clearPid(&driveMtrPID); clearPid(&tiltSrvPID); maxTiltAngle = /*145.0f*/35; bt = intruder; } if (!fp) { fp = fopen("hist8.data", "w"); if (!fp) fprintf(stderr, "MoveToBlob history file not opened!\n"); } trackBlobs(bt, frame, 0); blobfound = bt->blobs->trackable; center = bt->blobs->center; if (!blobfound) { removeState(&is, "intruder_found"); removeState(&is, "gp_found"); //sendCommand(STOP, is.ltMotorVal=0, is.rtMotorVal=0); is.ltMotorVal=0, is.rtMotorVal=0; send_command(MOTOR_DIR, MOTOR_STOP); } if (status==1&&blobfound) { if (bt == intruder) { removeState(&is, "intruder_found"); addState(&is, "intruder_near"); } return 1; } if (is.hdTiltAngle<45.0f/*145.0f*/) { //sendCommand(STOP, is.ltMotorVal=0, is.rtMotorVal=0); is.ltMotorVal=0, is.rtMotorVal=0; send_command(MOTOR_DIR, MOTOR_STOP); fprintf(fp, "Got intruder \n"); printf("waiting for 2sec to stabilize intruder...\n"); sw = getTickCount(); while ((getTickCount()-sw)<2000) { printf("time = %dms\n", getTickCount()-sw); frame = cvQueryFrame(capture); } status = 1; return 1; } else { if (blobfound) { bx = ((double)center.x/(double)fsize.width)*100.0; by = ((double)center.y/(double)fsize.height)*100.0; printf("pos bx=%g, by=%g\n", bx, by); fprintf(fp, "pos bx=%g, by=%g\n", bx, by); error = bx-50.0; //resp = getPidRespVerb(&driveMtrPID, error, fp, "DriveMtr"); resp = (double)error*1.0; if (resp>120.0) resp = 120.0; else if (resp<-120.0) resp = -120.0; if (resp > 0) { is.ltMotorVal = /*120*/240; is.rtMotorVal = /*120-(int)resp*/0; } else { is.ltMotorVal = /*120+(int)resp*/0; is.rtMotorVal = 240; } error = by-50.0; // resp = getPidRespVerb(&tiltSrvPID, error, fp, "TiltSrv"); resp = (double)error*0.05f; is.hdTiltAngle -= resp; if (is.hdTiltAngle < MAX_SERVO_TILT_DOWN) is.hdTiltAngle = MAX_SERVO_TILT_DOWN; else if (is.hdTiltAngle > MAX_SERVO_TILT_UP) is.hdTiltAngle = MAX_SERVO_TILT_UP; //writeServo(TILT_SRV, is.hdTiltAngle); send_command(SERVO_TILT, (byte)((int)is.hdTiltAngle)); //sendCommand(DIFF_DRV, is.ltMotorVal, is.rtMotorVal); send_command(LEFT_MTR_VAL, 128-is.ltMotorVal/2); send_command(RIGHT_MTR_VAL, 128-is.rtMotorVal/2); send_command(MOTOR_DIR, MOTOR_FWD); fprintf(fp, "CMD: x=%d y=%d pan=%g, tilt=%g lmotor=%d rmotor=%d\n\n", center.x, center.y, is.hdPanAngle, is.hdTiltAngle, 128-is.ltMotorVal/2, 128-is.rtMotorVal/2); } } return 1; }
void Animation::advanceTime(Number passedTime) { /* if(!_isPlaying || !_isActive) { return; } */ passedTime *= _timeScale; int l = _armature->_boneList.size(); int i; int j; int k = l; uint stateListLength; Bone* bone; String boneName; Number weigthLeft; Number x; Number y; Number skewX; Number skewY; Number scaleX; Number scaleY; Number pivotX; Number pivotY; Number layerTotalWeight; AnimationState* animationState; TimelineState* timelineState; Number weight; DBTransform *transform = 0; Point *pivot = 0; l --; while(k --) { bone = _armature->_boneList[k]; boneName = bone->name; weigthLeft = 1; x = 0; y = 0; skewX = 0; skewY = 0; scaleX = 0; scaleY = 0; pivotX = 0; pivotY = 0; i = _animationLayer.size(); while(i --) { layerTotalWeight = 0; std::vector<AnimationState*> *animationStateList = _animationLayer[i]; stateListLength = animationStateList->size(); for(j = 0;j < (int)stateListLength;j ++) { animationState = animationStateList->at(j); if(k == l) { if(animationState->advanceTime(passedTime)) { removeState(animationState); j --; stateListLength --; continue; } } timelineState = animationState->_timelineStates[boneName]; if(timelineState && timelineState->tweenActive) { weight = animationState->_fadeWeight * animationState->weight * weigthLeft; transform = &timelineState->transform; pivot = &timelineState->pivot; x += transform->x * weight; y += transform->y * weight; skewX += transform->skewX * weight; skewY += transform->skewY * weight; scaleX += transform->scaleX * weight; scaleY += transform->scaleY * weight; pivotX += pivot->x * weight; pivotY += pivot->y * weight; layerTotalWeight += weight; } } if(layerTotalWeight >= weigthLeft) { break; } else { weigthLeft -= layerTotalWeight; } } transform = &bone->tween; pivot = &bone->_tweenPivot; transform->x = x; transform->y = y; transform->skewX = skewX; transform->skewY = skewY; transform->scaleX = scaleX; transform->scaleY = scaleY; pivot->x = pivotX; pivot->y = pivotY; } }
void Game::toEntryPoint() { for (int i=((int)states.size())-1; i>=0; --i) removeState(states[i]); }
QJsonObject copySelected(const Scenario_T& sm, QObject* parent) { auto selectedConstraints = selectedElements(getConstraints(sm)); auto selectedEvents = selectedElements(getEvents(sm)); auto selectedTimeNodes = selectedElements(getTimeNodes(sm)); auto selectedStates = selectedElements(getStates(sm)); for(const ConstraintModel* constraint : selectedConstraints) { auto start_it = find_if(selectedStates, [&] (const StateModel* state) { return state->id() == constraint->startState();}); if(start_it == selectedStates.end()) { selectedStates.push_back(&sm.state(constraint->startState())); } auto end_it = find_if(selectedStates, [&] (const StateModel* state) { return state->id() == constraint->endState();}); if(end_it == selectedStates.end()) { selectedStates.push_back(&sm.state(constraint->endState())); } } for(const StateModel* state : selectedStates) { auto ev_it = find_if(selectedEvents, [&] (const EventModel* event) { return state->eventId() == event->id(); }); if(ev_it == selectedEvents.end()) { selectedEvents.push_back(&sm.event(state->eventId())); } // If the previous or next constraint is not here, we set it to null in a copy. } for(const EventModel* event : selectedEvents) { auto tn_it = find_if(selectedTimeNodes, [&] (const TimeNodeModel* tn) { return tn->id() == event->timeNode(); }); if(tn_it == selectedTimeNodes.end()) { selectedTimeNodes.push_back(&sm.timeNode(event->timeNode())); } // If some events aren't there, we set them to null in a copy. } std::vector<TimeNodeModel*> copiedTimeNodes; copiedTimeNodes.reserve(selectedTimeNodes.size()); for(const auto& tn : selectedTimeNodes) { auto clone_tn = new TimeNodeModel(*tn, tn->id(), parent); auto events = clone_tn->events(); for(const auto& event : events) { auto absent = none_of(selectedEvents, [&] (const EventModel* ev) { return ev->id() == event; }); if(absent) clone_tn->removeEvent(event); } copiedTimeNodes.push_back(clone_tn); } std::vector<EventModel*> copiedEvents; copiedEvents.reserve(selectedEvents.size()); for(const auto& ev : selectedEvents) { auto clone_ev = new EventModel(*ev, ev->id(), parent); auto states = clone_ev->states(); for(const auto& state : states) { auto absent = none_of(selectedStates, [&] (const StateModel* st) { return st->id() == state; }); if(absent) clone_ev->removeState(state); } copiedEvents.push_back(clone_ev); } std::vector<StateModel*> copiedStates; copiedStates.reserve(selectedStates.size()); auto& stack = iscore::IDocument::documentContext(*parent).commandStack; for(const StateModel* st : selectedStates) { auto clone_st = new StateModel(*st, st->id(), stack, parent); // NOTE : we must not serialize the state with their previous / next constraint // since they will change once pasted and cause crash at the end of the ctor // of StateModel. They are saved in the previous / next state of constraint anyway. SetNoPreviousConstraint(*clone_st); SetNoNextConstraint(*clone_st); copiedStates.push_back(clone_st); } QJsonObject base; base["Constraints"] = arrayToJson(selectedConstraints); base["Events"] = arrayToJson(copiedEvents); base["TimeNodes"] = arrayToJson(copiedTimeNodes); base["States"] = arrayToJson(copiedStates); for(auto elt : copiedTimeNodes) delete elt; for(auto elt : copiedEvents) delete elt; for(auto elt : copiedStates) delete elt; return base; }
void LogicObject:: changeState(State* oldState, State* newState) { removeState(oldState); addState(newState); }