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);
}
