/// <summary> /// Attaches the bodies with revolute joints. /// </summary> /// <param name="world">The world.</param> /// <param name="bodies">The bodies.</param> /// <param name="localAnchorA">The local anchor A.</param> /// <param name="localAnchorB">The local anchor B.</param> /// <param name="connectFirstAndLast">if set to <c>true</c> [connect first and last].</param> /// <param name="collideConnected">if set to <c>true</c> [collide connected].</param> public static List<RevoluteJoint> AttachBodiesWithRevoluteJoint(World world, List<Body> bodies, Vector2 localAnchorA, Vector2 localAnchorB, bool connectFirstAndLast, bool collideConnected) { List<RevoluteJoint> joints = new List<RevoluteJoint>(bodies.Count + 1); for (int i = 1; i < bodies.Count; i++) { RevoluteJoint joint = new RevoluteJoint(bodies[i], bodies[i - 1], localAnchorA, localAnchorB); joint.CollideConnected = collideConnected; world.AddJoint(joint); joints.Add(joint); } if (connectFirstAndLast) { RevoluteJoint lastjoint = new RevoluteJoint(bodies[0], bodies[bodies.Count - 1], localAnchorA, localAnchorB); lastjoint.CollideConnected = collideConnected; world.AddJoint(lastjoint); joints.Add(lastjoint); } return joints; }
/// <summary> /// Requires two existing revolute or prismatic joints (any combination will work). /// The provided joints must attach a dynamic body to a static body. /// </summary> /// <param name="jointA">The first joint.</param> /// <param name="jointB">The second joint.</param> /// <param name="ratio">The ratio.</param> public GearJoint(Joint jointA, Joint jointB, float ratio) : base(jointA.BodyA, jointA.BodyB) { JointType = JointType.Gear; JointA = jointA; JointB = jointB; Ratio = ratio; JointType type1 = jointA.JointType; JointType type2 = jointB.JointType; // Make sure its the right kind of joint Debug.Assert(type1 == JointType.Revolute || type1 == JointType.Prismatic || type1 == JointType.FixedRevolute || type1 == JointType.FixedPrismatic); Debug.Assert(type2 == JointType.Revolute || type2 == JointType.Prismatic || type2 == JointType.FixedRevolute || type2 == JointType.FixedPrismatic); // In the case of a prismatic and revolute joint, the first body must be static. if (type1 == JointType.Revolute || type1 == JointType.Prismatic) Debug.Assert(jointA.BodyA.BodyType == BodyType.Static); if (type2 == JointType.Revolute || type2 == JointType.Prismatic) Debug.Assert(jointB.BodyA.BodyType == BodyType.Static); float coordinate1 = 0.0f, coordinate2 = 0.0f; switch (type1) { case JointType.Revolute: BodyA = jointA.BodyB; _revolute1 = (RevoluteJoint) jointA; LocalAnchor1 = _revolute1.LocalAnchorB; coordinate1 = _revolute1.JointAngle; break; case JointType.Prismatic: BodyA = jointA.BodyB; _prismatic1 = (PrismaticJoint) jointA; LocalAnchor1 = _prismatic1.LocalAnchorB; coordinate1 = _prismatic1.JointTranslation; break; case JointType.FixedRevolute: BodyA = jointA.BodyA; _fixedRevolute1 = (FixedRevoluteJoint) jointA; LocalAnchor1 = _fixedRevolute1.LocalAnchorA; coordinate1 = _fixedRevolute1.JointAngle; break; case JointType.FixedPrismatic: BodyA = jointA.BodyA; _fixedPrismatic1 = (FixedPrismaticJoint) jointA; LocalAnchor1 = _fixedPrismatic1.LocalAnchorA; coordinate1 = _fixedPrismatic1.JointTranslation; break; } switch (type2) { case JointType.Revolute: BodyB = jointB.BodyB; _revolute2 = (RevoluteJoint) jointB; LocalAnchor2 = _revolute2.LocalAnchorB; coordinate2 = _revolute2.JointAngle; break; case JointType.Prismatic: BodyB = jointB.BodyB; _prismatic2 = (PrismaticJoint) jointB; LocalAnchor2 = _prismatic2.LocalAnchorB; coordinate2 = _prismatic2.JointTranslation; break; case JointType.FixedRevolute: BodyB = jointB.BodyA; _fixedRevolute2 = (FixedRevoluteJoint) jointB; LocalAnchor2 = _fixedRevolute2.LocalAnchorA; coordinate2 = _fixedRevolute2.JointAngle; break; case JointType.FixedPrismatic: BodyB = jointB.BodyA; _fixedPrismatic2 = (FixedPrismaticJoint) jointB; LocalAnchor2 = _fixedPrismatic2.LocalAnchorA; coordinate2 = _fixedPrismatic2.JointTranslation; break; } _ant = coordinate1 + Ratio*coordinate2; }
public Weapon(SPRWorld sprWorld, Bot bot, Vector2 relativePosition, float relativeRotation, String textureName, Vector2 scale, WeaponType weaponType, float health, float power) { m_SPRWorld = sprWorld; m_Time = 0; this.m_owner = bot; this.m_firing = false; this.m_reloadTime = weaponType == WeaponType.melee ? 0 : .2f; this.m_reloading = 0; this.weaponType = weaponType; this.m_power = power; m_Position = relativePosition; m_Rotation = relativeRotation; m_Texture = TextureStatic.Get(textureName); m_Scale = scale; this.m_health = health; Vertices v = SPRWorld.computedSpritePolygons[textureName]; // Simplify the object until it has few enough verticies. while (v.Count > Physics.Settings.MaxPolygonVertices) // Infinite loop potential? { v = SimplifyTools.DouglasPeuckerSimplify(v, 2); // Where 2 is a completely arbitrary number? } v.Scale(ref scale); //v.Translate(ref relativePosition); v.Rotate(relativeRotation); Fixture f = FixtureFactory.CreatePolygon(v, 1f, bot.Body, relativePosition); m_Fixture = f; f.Friction = 0.5f; f.Restitution = 0f; f.UserData = this; if (this.weaponType == WeaponType.melee) { Body tempBody = BodyFactory.CreateBody(m_SPRWorld.World); tempBody.BodyType = BodyType.Dynamic; Vertices v2 = SPRWorld.computedSpritePolygons["Axe"]; // Simplify the object until it has few enough verticies. while (v2.Count > Physics.Settings.MaxPolygonVertices) // Infinite loop potential? { v2 = SimplifyTools.DouglasPeuckerSimplify(v2, 2); // Where 2 is a completely arbitrary number? } Fixture f2 = FixtureFactory.CreatePolygon(SPRWorld.computedSpritePolygons[textureName], 0.1f, tempBody); f2.Friction = 0.5f; f2.Restitution = 0f; tempBody.SetTransform(this.GetAbsPosition(), this.GetAbsRotation()); Projectile justFired = new Projectile(m_SPRWorld, tempBody, TextureStatic.Get("Axe"), new Vector2(0, 0), this.GetRelRotation(), 5, Settings.MetersPerPixel * 80, 80 * Settings.MetersPerPixel, m_power, m_health); f2.UserData = justFired; f2.OnCollision += Projectile.OnMeleeHit; RevoluteJoint joint = JointFactory.CreateRevoluteJoint(m_SPRWorld.World, this.m_owner.Body, tempBody, Vector2.Zero); joint.MaxMotorTorque = 160; joint.LimitEnabled = true; joint.MotorEnabled = true; joint.LowerLimit = - (float)Math.PI / 4f; joint.UpperLimit = (float)Math.PI / 4f; m_AxeJoint = joint; m_SPRWorld.AddEntity(justFired); } }
/// <summary> /// Creates a revolute joint and adds it to the world /// </summary> /// <param name="bodyA"></param> /// <param name="bodyB"></param> /// <param name="localanchorB"></param> /// <returns></returns> public static RevoluteJoint CreateRevoluteJoint(Body bodyA, Body bodyB, Vector2 localanchorB) { Vector2 localanchorA = bodyA.GetLocalPoint(bodyB.GetWorldPoint(localanchorB)); RevoluteJoint joint = new RevoluteJoint(bodyA, bodyB, localanchorA, localanchorB); return joint; }