void KisTransformProcessingVisitor::transformClones(KisLayer *layer, KisUndoAdapter *undoAdapter) { QList<KisCloneLayerWSP> clones = layer->registeredClones(); foreach(KisCloneLayerSP clone, clones) { // we have just casted an object from a weak pointer, // so check validity first if(!clone) continue; KisTransformWorker tw(clone->projection(), m_sx, m_sy, m_shearx, m_sheary, m_shearOrigin.x(), m_shearOrigin.y(), m_angle, m_tx, m_ty, 0, m_filter); QTransform trans = tw.transform(); QTransform offsetTrans = QTransform::fromTranslate(clone->x(), clone->y()); QTransform newTrans = trans.inverted() * offsetTrans * trans; QPoint oldPos(clone->x(), clone->y()); QPoint newPos(newTrans.dx(), newTrans.dy()); KUndo2Command *command = new KisNodeMoveCommand2(clone, oldPos, newPos, undoAdapter); undoAdapter->addCommand(command); } }
/** ** Check map for obstacles in a line between 2 tiles ** ** This function uses Bresenham's line algorithm ** ** @param unit First tile ** @param goal Second tile ** @param flags Terrain type to check ** ** @return true, if an obstacle was found, false otherwise */ bool CheckObstaclesBetweenTiles(const Vec2i &unitPos, const Vec2i &goalPos, unsigned short flags, int *distance) { const Vec2i delta(abs(goalPos.x - unitPos.x), abs(goalPos.y - unitPos.y)); const Vec2i sign(unitPos.x < goalPos.x ? 1 : -1, unitPos.y < goalPos.y ? 1 : -1); int error = delta.x - delta.y; Vec2i pos(unitPos), oldPos(unitPos); while (pos.x != goalPos.x || pos.y != goalPos.y) { const int error2 = error * 2; if (error2 > -delta.y) { error -= delta.y; pos.x += sign.x; } if (error2 < delta.x) { error += delta.x; pos.y += sign.y; } if (Map.Info.IsPointOnMap(pos) == false) { DebugPrint("outside of map\n"); } else if (Map.Field(pos)->Flags & flags) { if (distance) { *distance = Distance(unitPos, pos); } return false; } oldPos = pos; } return true; }
void Map::createMap() { //TODO : Add a quadrant system const int w = m_pSurface->w / World::ratio; const int h = m_pSurface->h / World::ratio; b2Vec2 oldPos(0.0f,0.f); const float minDis = 3; for(unsigned int i=0; i<16*5; i++) { bool foundPos = false; while(foundPos == false) { b2Vec2 pos(rand()%w, rand()%h); if(b2DistanceSquared(pos, oldPos) >= minDis) { foundPos = true; oldPos = pos; } } Obstacle * obs = new Obstacle(m_pWorld, oldPos); obs->init(); m_Obstacles.push_back(obs); } }
//Wyrmgus start //bool CheckObstaclesBetweenTiles(const Vec2i &unitPos, const Vec2i &goalPos, unsigned short flags, int *distance) bool CheckObstaclesBetweenTiles(const Vec2i &unitPos, const Vec2i &goalPos, unsigned long flags, int *distance) //Wyrmgus end { const Vec2i delta(abs(goalPos.x - unitPos.x), abs(goalPos.y - unitPos.y)); const Vec2i sign(unitPos.x < goalPos.x ? 1 : -1, unitPos.y < goalPos.y ? 1 : -1); int error = delta.x - delta.y; Vec2i pos(unitPos), oldPos(unitPos); while (pos.x != goalPos.x || pos.y != goalPos.y) { const int error2 = error * 2; if (error2 > -delta.y) { error -= delta.y; pos.x += sign.x; } if (error2 < delta.x) { error += delta.x; pos.y += sign.y; } if (Map.Info.IsPointOnMap(pos) == false) { DebugPrint("outside of map\n"); //Wyrmgus start // } else if (Map.Field(pos)->Flags & flags) { } else if ((Map.Field(pos)->Flags & flags) && pos != goalPos) { // the goal's tile itself shouldn't be checked for an obstacle //Wyrmgus end if (distance) { *distance = Distance(unitPos, pos); } return false; } oldPos = pos; } return true; }
void FTLParticleChain::simulateStep() { std::vector<std::pair<Particle*, CollisionConstraint> > collisionConstraints; auto i = mParticles.begin()+1; Ogre::Vector3 oldPos(i->position); i->velocity += i->force * mTimestep * mParticleMassInv; i->position += i->velocity * mTimestep; Ogre::Vector3 correctionVec = computeFTLCorrectionVector(i); CollisionConstraint cc; if (checkPenetration(i->position, cc.closestSurfacePoint, cc.normal)) { collisionConstraints.push_back(std::make_pair(&(*i), cc)); i->position += computeCollisionCorrection(i->position, cc); } for (; i != mParticles.end()-1; ++i) { // recompute FTL correction, considering the previously added collision response i->position += computeFTLCorrectionVector(i); //correctionVec; auto succ = i + 1; Ogre::Vector3 nextOldPos(succ->position); succ->velocity += succ->force * mTimestep * mParticleMassInv; succ->position += succ->velocity * mTimestep; // this seems give the most stable results: // 1. compute FTL correction vector without considering collision, use this for damping // 2. add collision response // 3. recompute FTL correction and add it (see first line after for loop statement) Ogre::Vector3 nextCorrectionVec = computeFTLCorrectionVector(succ); if (checkPenetration(succ->position, cc.closestSurfacePoint, cc.normal)) { collisionConstraints.push_back(std::make_pair(&(*succ), cc)); succ->position += computeCollisionCorrection(succ->position, cc); } i->velocity = (i->position - oldPos - nextCorrectionVec * mFTLDamping - correctionVec * mPBDPointDamping) / mTimestep; correctionVec = nextCorrectionVec; oldPos = nextOldPos; } // perform update for last particle i->position += correctionVec; i->velocity = (i->position - oldPos - correctionVec * (mPBDPointDamping + mFTLDamping)) / mTimestep; // finally project collision constraints once more and simulate friction by damping the velocity for (auto ic = collisionConstraints.begin(); ic != collisionConstraints.end(); ++ic) { Particle &particle = *ic->first; particle.position += computeCollisionCorrection(particle.position, ic->second); particle.velocity -= mTimestep * mParticleMassInv * computeFrictionDamping(ic->second.normal, particle.velocity); } }
void GameMap::draw() { std::vector<bool> drawn(between.size(), false); std::vector<Point> oldPos(between.size()); int start = 0; std::sort(between.begin(), between.end(), SortBetween()); for (unsigned int i = 0; i < between.size(); ++i) { oldPos[i].x = between[i]->getX(); oldPos[i].y = between[i]->getY(); between[i]->setPos(getX() + oldPos[i].x, getY() + oldPos[i].y); } for (unsigned int i = 0; i < tiles.size(); ++i) { /* Don't waste time, don't draw unvisible tiles. ( It's also possible that the size of the map is inferior to the screen size ) */ if (visible(tiles[i])) { for (unsigned int j = start; j < between.size(); ++j) { if (!drawn[j]) { if (between[j]->getY() < (getY() + tiles[i].y)) { DrawableRect rect; rect.setPos(tiles[i].x + getX(), tiles[i].y + getY()); rect.resize(tileWidth, tileHeight); if (between[j]->collide(rect)) { between[j]->draw(); drawn[j] = true; start = j; } } } } Sprite &tile = tilesets[tiles[i].tileset]; tile.setTile(tiles[i].tileX, tiles[i].tileY, tileWidth, tileHeight); tile.setPos(getX() + tiles[i].x, getY() + tiles[i].y); tile.draw(); } } for (unsigned int i = 0; i < between.size(); ++i) { if (!drawn[i]) between[i]->draw(); between[i]->setPos(oldPos[i]); between[i]->clearMove(); } }
void Particle::update(float dt, const Vec3f& accel, const std::vector<Segment>& segs) { // Reduce the time to live, and if dead or not updating positions automatically return _lifeLeft -= dt; if (!isAlive()) { return; } // Update the position _oldPosition = _position; _position += _velocity * dt; // Update the velocity _oldVelocity = _velocity; _velocity += accel * dt; Vec2f entPos(31, 3); /// @todo HACK FOR DEMO Vec2f oldPos(_oldPosition[0], _oldPosition[1]); Vec2f newPos(_position[0], _position[1]); Segment pline(oldPos + entPos, newPos + entPos); for (size_t i = 0; i < segs.size(); ++i) { const Segment& s = segs[i]; // need the normal of this segment. Vec2f n = perp(s.v2 - s.v1); if (dot(n, Vec2f(_oldVelocity[0], _oldVelocity[1])) > 0) { n = -n; } normalize(n); Vec2f p; float t = intersectLine(p, pline, s); if (t >= 0 && t <= 1) { Vec2f I = pline.v2 - pline.v1; Vec2f R = I - 2 * dot(n, I) * n; Vec2f p = pline.v1 + I * t + R * (1 - t); Vec2f v = normal(R) * length(_velocity) * 0.5f; p -= entPos; _position[0] = p[0]; _position[1] = p[1]; _velocity[0] = v[0]; _velocity[1] = v[1]; _oldPosition = _position; _oldVelocity = _velocity; break; } } }
void testPortalTeleport(void) { setUp(); Portal p1(*tileSet, 0, 0, 100, 100, true); Portal p2(*tileSet, 100, 100, 0, 0, false); Player player; FloatRect oldPos(p1.rect.left, p1.rect.top, p1.rect.width, p1.rect.height); p1.teleport(&player, &p2); p1.update(10); TS_ASSERT(oldPos.top != p1.rect.top); TS_ASSERT(oldPos.left != p1.rect.left); TS_ASSERT(oldPos.width != p1.rect.width); TS_ASSERT(oldPos.height != p1.rect.height); breakDown(); }
void KisCropProcessingVisitor::visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter) { /** * TODO: implement actual robust cropping of the selections, * including the cropping of vector (!) selection. */ if (m_cropLayers) { KisTransaction transaction(kundo2_noi18n("crop"), node->paintDevice()); node->paintDevice()->crop(m_rect); transaction.commit(undoAdapter); } if (m_moveLayers) { QPoint oldPos(node->x(), node->y()); QPoint newPos(node->x() - m_rect.x(), node->y() - m_rect.y()); KUndo2Command *command = new KisNodeMoveCommand2(node, oldPos, newPos); undoAdapter->addCommand(command); } }
bool ChessPiece::isOpponentPieceEnPassant(const int boardPos) const { Q_ASSERT(!m_parentPlayer.isNull()); auto opponentPlayer(m_parentPlayer.toStrongRef()->opponentPlayer()); Q_ASSERT(!opponentPlayer.isNull()); if (opponentPlayer->lastMove()) { auto oppMove = opponentPlayer->lastMove(); if (oppMove->moveStates() & ChessTypes::MoveEnPassant && oppMove->newPos().col() == ChessPos::col(boardPos)) { const int boardMiddlePos = (oppMove->oldPos() + oppMove->newPos()) / 2; if (boardMiddlePos == boardPos && opponentPlayer->chessPieceAt(oppMove->newPos())) return true; } } return false; }
void WorldSession::HandleMoveTeleportAck(WorldPacket& recvData) { ;//sLog->outDebug(LOG_FILTER_NETWORKIO, "MSG_MOVE_TELEPORT_ACK"); uint64 guid; recvData.readPackGUID(guid); uint32 flags, time; recvData >> flags >> time; // unused ;//sLog->outStaticDebug("Guid " UI64FMTD, guid); ;//sLog->outStaticDebug("Flags %u, time %u", flags, time/IN_MILLISECONDS); Player* plMover = _player->m_mover->ToPlayer(); if (!plMover || !plMover->IsBeingTeleportedNear()) return; if (guid != plMover->GetGUID()) return; plMover->SetSemaphoreTeleportNear(0); uint32 old_zone = plMover->GetZoneId(); WorldLocation const& dest = plMover->GetTeleportDest(); Position oldPos(*plMover); plMover->UpdatePosition(dest, true); // xinef: teleport pets if they are not unsummoned if (Pet* pet = plMover->GetPet()) { if (!pet->IsWithinDist3d(plMover, plMover->GetMap()->GetVisibilityRange()-5.0f)) pet->NearTeleportTo(plMover->GetPositionX(), plMover->GetPositionY(), plMover->GetPositionZ(), pet->GetOrientation()); } if (oldPos.GetExactDist2d(plMover) > 100.0f) { uint32 newzone, newarea; plMover->GetZoneAndAreaId(newzone, newarea, true); plMover->UpdateZone(newzone, newarea); // new zone if (old_zone != newzone) { // honorless target if (plMover->pvpInfo.IsHostile) plMover->CastSpell(plMover, 2479, true); // in friendly area else if (plMover->IsPvP() && !plMover->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_IN_PVP)) plMover->UpdatePvP(false, false); } } // resummon pet GetPlayer()->ResummonPetTemporaryUnSummonedIfAny(); //lets process all delayed operations on successful teleport GetPlayer()->ProcessDelayedOperations(); plMover->GetMotionMaster()->ReinitializeMovement(); // pussywizard: client forgets about losing control, resend it if (plMover->HasUnitState(UNIT_STATE_FLEEING|UNIT_STATE_CONFUSED) || plMover->IsCharmed()) // only in such cases SetClientControl(self, false) is sent plMover->SetClientControl(plMover, false, true); }
void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove) { Q_Q(QWidget); Q_ASSERT(q->testAttribute(Qt::WA_WState_Created)); if ((q->windowType() == Qt::Desktop)) return; QPoint oldPos(q->pos()); QSize oldSize(q->size()); QRect oldGeom(data.crect); // Lose maximized status if deliberate resize if (w != oldSize.width() || h != oldSize.height()) data.window_state &= ~Qt::WindowMaximized; if (extra) { // any size restrictions? w = qMin(w,extra->maxw); h = qMin(h,extra->maxh); w = qMax(w,extra->minw); h = qMax(h,extra->minh); } if (q->isWindow()) topData()->normalGeometry = QRect(0, 0, -1, -1); else { uint s = data.window_state; s &= ~(Qt::WindowMaximized | Qt::WindowFullScreen); data.window_state = s; } bool isResize = w != oldSize.width() || h != oldSize.height(); if (!isMove && !isResize) return; if (q->isWindow()) { if (w == 0 || h == 0) { q->setAttribute(Qt::WA_OutsideWSRange, true); if (q->isVisible() && q->testAttribute(Qt::WA_Mapped)) hide_sys(); data.crect = QRect(x, y, w, h); data.window_state &= ~Qt::WindowFullScreen; } else if (q->isVisible() && q->testAttribute(Qt::WA_OutsideWSRange)) { q->setAttribute(Qt::WA_OutsideWSRange, false); // put the window in its place and show it q->internalWinId()->SetRect(TRect(TPoint(x, y), TSize(w, h))); data.crect.setRect(x, y, w, h); show_sys(); } else { QRect r = QRect(x, y, w, h); data.crect = r; q->internalWinId()->SetRect(TRect(TPoint(x, y), TSize(w, h))); topData()->normalGeometry = data.crect; } } else { data.crect.setRect(x, y, w, h); QTLWExtra *tlwExtra = q->window()->d_func()->maybeTopData(); const bool inTopLevelResize = tlwExtra ? tlwExtra->inTopLevelResize : false; if (q->isVisible() && (!inTopLevelResize || q->internalWinId())) { // Top-level resize optimization does not work for native child widgets; // disable it for this particular widget. if (inTopLevelResize) tlwExtra->inTopLevelResize = false; if (!isResize && maybeBackingStore()) moveRect(QRect(oldPos, oldSize), x - oldPos.x(), y - oldPos.y()); else invalidateBuffer_resizeHelper(oldPos, oldSize); if (inTopLevelResize) tlwExtra->inTopLevelResize = true; } if (q->testAttribute(Qt::WA_WState_Created)) setWSGeometry(); } if (q->isVisible()) { if (isMove && q->pos() != oldPos) { QMoveEvent e(q->pos(), oldPos); QApplication::sendEvent(q, &e); } if (isResize) { bool slowResize = qgetenv("QT_SLOW_TOPLEVEL_RESIZE").toInt(); const bool setTopLevelResize = !slowResize && q->isWindow() && extra && extra->topextra && !extra->topextra->inTopLevelResize; if (setTopLevelResize) extra->topextra->inTopLevelResize = true; QResizeEvent e(q->size(), oldSize); QApplication::sendEvent(q, &e); if (!q->testAttribute(Qt::WA_StaticContents) && q->internalWinId()) q->internalWinId()->DrawDeferred(); if (setTopLevelResize) extra->topextra->inTopLevelResize = false; } } else { if (isMove && q->pos() != oldPos) q->setAttribute(Qt::WA_PendingMoveEvent, true); if (isResize) q->setAttribute(Qt::WA_PendingResizeEvent, true); } }
void movement(void) { //Exit if(MultiKeys[033]){ exit( EXIT_SUCCESS ); } int time = glutGet(GLUT_ELAPSED_TIME)/1000; glm::vec3 oldPos(0, 0, 0); //Movement Player 1 if(MultiKeys['w'] ){ oldPos = player1->pos; player1->pos[0] = player1->pos[0]+(timeDiff*0.005 * sin(degToRad(player1->angle))); player1->pos[2] = player1->pos[2]+(timeDiff*0.005 * cos(degToRad(player1->angle))); if(carDistance()) { player1->pos = oldPos; } // this makes sure that cars do not cross over the boundary walls, wall=20, boundary=18+view=2 else if(player1->pos[0] > 18 || player1->pos[0] < -18 || player1->pos[2] > 18 || player1->pos[2] < -18) { player1->pos = oldPos; } else { player1->viewDest = player1->pos; player1->viewSrc[0] = player1->viewDest[0]-(2 * sin(degToRad(player1->angle))); player1->viewSrc[2] = player1->viewDest[2]-(2 * cos(degToRad(player1->angle))); //Turning forwards if(MultiKeys['a']){ if(player1->angle > 360){ player1->angle = 0; player1->angle = player1->angle + timeDiff*0.2; } else{ player1->angle = player1->angle + timeDiff*0.2; } } if(MultiKeys['d']){ if(player1->angle < 0){ player1->angle = 360; player1->angle = player1->angle - timeDiff*0.2; } else{ player1->angle = player1->angle - timeDiff*0.2; } } } } if(MultiKeys['s']){ oldPos = player1->pos; player1->pos[0] = player1->pos[0]-(timeDiff*0.005 * sin(degToRad(player1->angle))); player1->pos[2] = player1->pos[2]-(timeDiff*0.005 * cos(degToRad(player1->angle))); if(carDistance()) { player1->pos = oldPos; } else if(player1->pos[0] > 18 || player1->pos[0] < -18 || player1->pos[2] > 18 || player1->pos[2] < -18) { player1->pos = oldPos; } else { player1->viewDest = player1->pos; player1->viewSrc[0] = player1->viewDest[0]-(2 * sin(degToRad(player1->angle))); player1->viewSrc[2] = player1->viewDest[2]-(2 * cos(degToRad(player1->angle))); //Turning Backwards if(MultiKeys['d']){ //player1->pos[0] = player1->pos[0]+0.005; if(player1->angle > 360){ player1->angle = 0; player1->angle = player1->angle + timeDiff*0.2; } else{ player1->angle = player1->angle + timeDiff*0.2; } } if(MultiKeys['a']){ //player1->pos[0] = player1->pos[0]-0.005; if(player1->angle < 0){ player1->angle = 360; player1->angle = player1->angle - timeDiff*0.2; } else{ player1->angle = player1->angle - timeDiff*0.2; } } } } //Movement Player 2 if(MultiKeys['i']){ oldPos = player2->pos; player2->pos[0] = player2->pos[0]+(timeDiff*0.005 * sin(degToRad(player2->angle))); player2->pos[2] = player2->pos[2]+(timeDiff*0.005 * cos(degToRad(player2->angle))); if(carDistance()) { player2->pos = oldPos; } else if(player2->pos[0] > 18 || player2->pos[0] < -18 || player2->pos[2] > 18 || player2->pos[2] < -18) { player2->pos = oldPos; } else { player2->viewDest = player2->pos; player2->viewSrc[0] = player2->viewDest[0]-(2 * sin(degToRad(player2->angle))); player2->viewSrc[2] = player2->viewDest[2]-(2 * cos(degToRad(player2->angle))); //Turning forwards if(MultiKeys['j']){ //player2->pos[0] = player2->pos[0]+0.005; if(player2->angle > 360){ player2->angle = 0; player2->angle = player2->angle + timeDiff*0.2; } else{ player2->angle = player2->angle + timeDiff*0.2; } } if(MultiKeys['l']){ //player2->pos[0] = player2->pos[0]-0.005; if(player2->angle < 0){ player2->angle = 360; player2->angle = player2->angle - timeDiff*0.2; } else{ player2->angle = player2->angle - timeDiff*0.2; } } } } if(MultiKeys['k']){ oldPos = player2->pos; player2->pos[0] = player2->pos[0]-(timeDiff*0.005 * sin(degToRad(player2->angle))); player2->pos[2] = player2->pos[2]-(timeDiff*0.005 * cos(degToRad(player2->angle))); if(carDistance()) { player2->pos = oldPos; } else if(player2->pos[0] > 18 || player2->pos[0] < -18 || player2->pos[2] > 18 || player2->pos[2] < -18) { player2->pos = oldPos; } else { player2->viewDest = player2->pos; player2->viewSrc[0] = player2->viewDest[0]-(2 * sin(degToRad(player2->angle))); player2->viewSrc[2] = player2->viewDest[2]-(2 * cos(degToRad(player2->angle))); //Turning Backwards if(MultiKeys['l']){ //player2->pos[0] = player2->pos[0]+0.005; if(player2->angle > 360){ player2->angle = 0; player2->angle = player2->angle + timeDiff*0.2; } else{ player2->angle = player2->angle + timeDiff*0.2; } } if(MultiKeys['j']){ //player2->pos[0] = player2->pos[0]-0.005; if(player2->angle < 0){ player2->angle = 360; player2->angle = player2->angle - timeDiff*0.2; } else{ player2->angle = player2->angle - timeDiff*0.2; } } } } //Fire Weapon Player 1 if(MultiKeys['e']){ weapon->angle = player1->angle; weapon->pos[0] = player1->pos[0]+(1.4 * sin(degToRad(weapon->angle))); weapon->pos[2] = player1->pos[2]+(1.4 * cos(degToRad(weapon->angle))); WeaTimer = 0; } //Fire Weapon Player 1 if(MultiKeys['u']){ weapon2->angle = player2->angle; weapon2->pos[0] = player2->pos[0]+(1.4 * sin(degToRad(weapon2->angle))); weapon2->pos[2] = player2->pos[2]+(1.4 * cos(degToRad(weapon2->angle))); WeaTimer2 = 0; } }