Example #1
0
	bool Player::handleMessage(const Telegram& msg)
	{
		bool result = false;

		b2Body& body = getBody();
		const float speed = 5.f;
		if ((msg.msg & X) > 0)
		{
			float xAxis = *(float*)msg.extraInfo;
			body.SetLinearVelocity(b2Vec2(xAxis * speed, body.GetLinearVelocity().y));
			result = true;
		}
		if ((msg.msg & Y) > 0)
		{
			float yAxis = *(float*)msg.extraInfo;
			body.SetLinearVelocity(b2Vec2(body.GetLinearVelocity().x, yAxis * speed));
			result = true;
			mpAnimator->setAnimation(TextureManager::getID(yAxis > 0 ? "inigo90_en_garde" : "inigo45_en_garde"));
		}

		b2Vec2 velocity = body.GetLinearVelocity();
		if (lengthSq(velocity) > speed * speed)
		{
			body.SetLinearVelocity(normalize(velocity) * speed);
		}

		return result;
	}
Example #2
0
void Ship::calcBase()
{
	Collider* c = m_body->getCollider();
	float min = FLT_MAX;
	while (c)
	{
		if (lengthSq(c->getTransform().p - m_body->getLocalCenter()) < min)
		{
			min = lengthSq(c->getTransform().p - m_body->getLocalCenter());
			m_base = (Brick*)c->getUserData();
		}

		c = c->getNext();
	}

}
Example #3
0
bool Vector::isNormalized() const
{
   FastFloat v;
   v.setSub( lengthSq(), Float_1 );
   v.abs();
   return v < Float_1e_4;
}
Example #4
0
double PLine::length() const
{
  if (!arc) 
    return sqrt(lengthSq());
  else {
    double radius = (from-arccenter).length();
    return radius * angle;
  }
}
Example #5
0
Math::Vector AvoidWalls::calculate()
{
	//std::vector<Math::Segment> feelers;

	Math::Vector v;
	double len;
	switch (mCycle) {
		case 0: v = parent()->heading() * 5.0; len = 5.0; break;
		case 1: v = (parent()->heading()*1.949 + parent()->heading().perpCW()*1.125); len = 2.25; break;
		case 2: v = (parent()->heading()*1.949 + parent()->heading().perpCCW()*1.125); len = 2.25; break;
		default: break;
	}

	Math::Segment feeler(parent()->pos(), parent()->pos() + v);
	/*feelers.push_back(Math::Segment(parent()->pos(), parent()->pos() + v1));
	feelers.push_back(Math::Segment(parent()->pos(), parent()->pos() + v2));
	feelers.push_back(Math::Segment(parent()->pos(), parent()->pos() + v3));*/

	double closestDist = 9999;
	Pointer<const Wall> closestWall;

	static EntityList<Wall> walls = parent()->world()->findEntities<Wall>();

	for (unsigned int i = 0; i < walls.size(); ++i) {
		Math::Point point;
		double dist;
		if (Math::segmentIntersection(feeler, walls[i]->segment(), point, dist)) {
			if (dist < closestDist) {
				closestDist = dist;
				closestWall = walls[i];
			}
		}
	}

	if (closestWall) {
		//--mCycle;
		double overshoot = len - closestDist;

		Math::Vector normal = (closestWall->segment().a - closestWall->segment().b).normal().perp();
		//normal must oppose feeler direction; if not, reverse it
		if (((feeler.b-feeler.a) + normal).lengthSq() > lengthSq(feeler)) normal *= -1;

		Math::Vector force = normal * overshoot;
		mResults[mCycle] = force;
	} else
		mResults[mCycle] = Math::Vector();

	if (++mCycle > 2) mCycle = 0;
	return mResults[0] + mResults[1] + mResults[2];
}
Example #6
0
static void
calculate_forces()
{
    /* O(n^2) approach */
    for(uint32_t j = 0; j < data.num_particles; j++) {
        v2 cur_pos = data.positions[j];
        for(uint32_t i = j + 1; i < data.num_particles; i++) {
            v2 other_pos = data.positions[i];
            v2 diff = get_min_diff(cur_pos, other_pos);
            float absForce = 1 / lengthSq(diff);
            v2 force = absForce * diff;
            data.forces[j] += force;
            data.forces[i] -= force;
        }
    }
}
Example #7
0
		Type length() const
		{
			return std::sqrt(lengthSq());
		}
/*****************************************************************************
 *    FUNCTION: length
 * DESCRIPTION: returns the length of the line segment
 *****************************************************************************/
double RecLineSegment2D::length() const
{
  return(sqrt(lengthSq()));
}
Example #9
0
		/**
		 * ベクトルの大きさの算出
		 * @return ベクトルの大きさ
		 */
		/*constexpr*/ T length() const noexcept {
			return std::sqrt(lengthSq());
		}
Example #10
0
/**
 * Returns the length of this Vector.
 *
 * @return the length of the Vector
**/
double Vector::length() const {
    return sqrt(lengthSq());
}
Example #11
0
void findPerpendicular(const float3 &v1, float3 &v2, float3 &v3) {
	DASSERT(lengthSq(v1) > constant::epsilon);

	v2 = float3(-v1.y, v1.z, v1.x);
	v3 = cross(v1, v2);
}
Example #12
0
float Quaternion::length() const {

  return Math::sqrt( lengthSq() );

}