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