public Wheel(
b2World b2world,
double x,
double y,
double width,
double length,
bool revolving,
bool powered
)
{
this.revolving = revolving;
this.powered = powered;
this.Initialize = car =>
{
/*
wheel object
pars:
car - car this wheel belongs to
x - horizontal position in meters relative to car's center
y - vertical position in meters relative to car's center
width - width in meters
length - length in meters
revolving - does this wheel revolve when steering?
powered - is this wheel powered?
*/
var position = new double[] { x, y };
//this.car=pars.car;
//this.revolving=pars.revolving;
//this.powered=pars.powered;
//initialize body
var def = new b2BodyDef();
def.type = b2Body.b2_dynamicBody;
def.position = car.body.GetWorldPoint(new b2Vec2(position[0], position[1]));
def.angle = car.body.GetAngle();
this.body = b2world.CreateBody(def);
//initialize shape
var fixdef = new b2FixtureDef();
fixdef.density = 1;
fixdef.isSensor = true; //wheel does not participate in collision calculations: resulting complications are unnecessary
var fixdef_shape = new b2PolygonShape();
fixdef.shape = fixdef_shape;
fixdef_shape.SetAsBox(width / 2, length / 2);
body.CreateFixture(fixdef);
var jointdef = new b2RevoluteJointDef();
//create joint to connect wheel to body
if (revolving)
{
jointdef.Initialize(car.body, body, body.GetWorldCenter());
jointdef.enableMotor = false; //we'll be controlling the wheel's angle manually
}
else
{
jointdef.Initialize(car.body, body, body.GetWorldCenter()
//, new b2Vec2(1, 0)
);
jointdef.enableLimit = true;
//jointdef.lowerTranslation = 0;
//jointdef.upperTranslation = 0;
}
b2world.CreateJoint(jointdef);
#region setAngle
this.setAngle =
(angle) =>
{
/*
angle - wheel angle relative to car, in degrees
*/
body.SetAngle(car.body.GetAngle() + angle.DegreesToRadians());
};
#endregion
#region getLocalVelocity
Func<double[]> getLocalVelocity = delegate
{
/*returns get velocity vector relative to car
*/
var res = car.body.GetLocalVector(car.body.GetLinearVelocityFromLocalPoint(new b2Vec2(position[0], position[1])));
return new double[] { res.x, res.y };
};
#endregion
#region getDirectionVector
Func<double[]> getDirectionVector = delegate
{
/*
returns a world unit vector pointing in the direction this wheel is moving
*/
if (getLocalVelocity()[1] > 0)
return vectors.rotate(new double[] { 0, 1 }, body.GetAngle());
else
return vectors.rotate(new double[] { 0, -1 }, body.GetAngle());
};
#endregion
#region getKillVelocityVector
Func<double[]> getKillVelocityVector = delegate
{
/*
substracts sideways velocity from this wheel's velocity vector and returns the remaining front-facing velocity vector
*/
var velocity = body.GetLinearVelocity();
var sideways_axis = getDirectionVector();
var dotprod = vectors.dot(new[] { velocity.x, velocity.y }, sideways_axis);
return new double[] { sideways_axis[0] * dotprod, sideways_axis[1] * dotprod };
};
#endregion
#region killSidewaysVelocity
this.killSidewaysVelocity = delegate
{
/*
removes all sideways velocity from this wheels velocity
*/
var kv = getKillVelocityVector();
body.SetLinearVelocity(new b2Vec2(kv[0], kv[1]));
};
#endregion
};
}
// SIN REVISAR
b2Joint j2b2Joint(b2World world, JObject jointValue)
{
b2Joint joint = null;
int bodyIndexA = (int)jointValue["bodyA"];
int bodyIndexB = (int)jointValue["bodyB"];
if (bodyIndexA >= m_bodies.Count || bodyIndexB >= m_bodies.Count)
return null;
// set features common to all joints
//var bodyA = m_bodies[bodyIndexA];
//var bodyB = m_bodies[bodyIndexB];
//var collideConnected = jointValue["collideConnected"] == null ? false : (bool)jointValue["collideConnected"];
// keep these in scope after the if/else below
b2RevoluteJointDef revoluteDef;
b2PrismaticJointDef prismaticDef;
b2DistanceJointDef distanceDef;
b2PulleyJointDef pulleyDef;
b2MouseJointDef mouseDef;
b2GearJointDef gearDef;
//b2WheelJoint wheelDef;
b2WeldJointDef weldDef;
b2FrictionJointDef frictionDef;
b2RopeJointDef ropeDef;
//MotorJoint motorDef;
b2JointDef jointDef = null;
b2Vec2 mouseJointTarget = new b2Vec2(0, 0);
string type = jointValue["type"].ToString() == null ? "" : jointValue["type"].ToString();
if (type == "revolute")
{
jointDef = revoluteDef = new b2RevoluteJointDef(); // JointFactory.CreateRevoluteJoint(world, bodyA, bodyB, jsonToVec("anchorB", jointValue));
revoluteDef.localAnchorA = jsonToVec("anchorA", jointValue);
revoluteDef.localAnchorB = jsonToVec("anchorB", jointValue);
revoluteDef.referenceAngle = jsonToFloat("refAngle", jointValue);
revoluteDef.enableLimit = jointValue["enableLimit"] == null ? false : (bool)jointValue["enableLimit"];
revoluteDef.lowerAngle = jsonToFloat("lowerLimit", jointValue);
revoluteDef.upperAngle = jsonToFloat("upperLimit", jointValue);
revoluteDef.enableMotor = jointValue["enableMotor"] == null ? false : (bool)jointValue["enableMotor"];
revoluteDef.motorSpeed = jsonToFloat("motorSpeed", jointValue);
revoluteDef.maxMotorTorque = jsonToFloat("maxMotorTorque", jointValue);
}
else if (type == "prismatic")
{
jointDef = prismaticDef = new b2PrismaticJointDef(); //JointFactory.CreatePrismaticJoint(world, bodyA, bodyB, localAnchorB, localAxis);
prismaticDef.localAnchorA = jsonToVec("anchorA", jointValue);
prismaticDef.localAnchorB = jsonToVec("anchorB", jointValue);
if (jointValue["localAxisA"] != null)
prismaticDef.localAxisA = jsonToVec("localAxisA", jointValue);
else
prismaticDef.localAxisA = jsonToVec("localAxis1", jointValue);
prismaticDef.referenceAngle = jsonToFloat("refAngle", jointValue);
prismaticDef.enableLimit = jointValue["enableLimit"] == null ? false : (bool)jointValue["enableLimit"];
prismaticDef.lowerTranslation = jsonToFloat("lowerLimit", jointValue);
prismaticDef.upperTranslation = jsonToFloat("upperLimit", jointValue);
prismaticDef.enableMotor = jointValue["enableMotor"] == null ? false : (bool)jointValue["enableMotor"];
prismaticDef.motorSpeed = jsonToFloat("motorSpeed", jointValue);
prismaticDef.maxMotorForce = jsonToFloat("maxMotorForce", jointValue);
}
else if (type == "distance")
{
jointDef = distanceDef = new b2DistanceJointDef();
distanceDef.localAnchorA = jsonToVec("anchorA", jointValue);
distanceDef.localAnchorB = jsonToVec("anchorB", jointValue);
distanceDef.length = jsonToFloat("length", jointValue);
distanceDef.frequencyHz = jsonToFloat("frequency", jointValue);
distanceDef.dampingRatio = jsonToFloat("dampingRatio", jointValue);
}
else if (type == "pulley")
{
jointDef = pulleyDef = new b2PulleyJointDef();
pulleyDef.groundAnchorA = jsonToVec("groundAnchorA", jointValue);
pulleyDef.groundAnchorB = jsonToVec("groundAnchorB", jointValue);
pulleyDef.localAnchorA = jsonToVec("anchorA", jointValue);
pulleyDef.localAnchorB = jsonToVec("anchorB", jointValue);
pulleyDef.lengthA = jsonToFloat("lengthA", jointValue);
pulleyDef.lengthB = jsonToFloat("lengthB", jointValue);
pulleyDef.ratio = jsonToFloat("ratio", jointValue);
}
else if (type == "mouse")
{
jointDef = mouseDef = new b2MouseJointDef();
mouseJointTarget = jsonToVec("target", jointValue);
mouseDef.target = jsonToVec("anchorB", jointValue);// alter after creating joint
mouseDef.maxForce = jsonToFloat("maxForce", jointValue);
mouseDef.frequencyHz = jsonToFloat("frequency", jointValue);
mouseDef.dampingRatio = jsonToFloat("dampingRatio", jointValue);
}
// Gear joints are apparently not implemented in JBox2D yet, but
// when they are, commenting out the following section should work.
else if (type == "gear")
{
jointDef = gearDef = new b2GearJointDef(); //JointFactory.CreateGearJoint(world, joint1, joint2, ratio);
int jointIndex1 = (int)jointValue["joint1"];
int jointIndex2 = (int)jointValue["joint2"];
var joint1 = m_joints[jointIndex1];
var joint2 = m_joints[jointIndex2];
var ratio = jsonToFloat("ratio", jointValue);
//joint = gearDef = JointFactory.CreateGearJoint(world, joint1, joint2, ratio);
}
// Wheel joints are apparently not implemented in JBox2D yet, but
// when they are, commenting out the following section should work.
else if (type == "wheel")
{
jointDef = revoluteDef = new b2RevoluteJointDef();
revoluteDef.localAnchorA = jsonToVec("anchorA", jointValue);
revoluteDef.localAnchorB = jsonToVec("anchorB", jointValue);
revoluteDef.enableMotor = jointValue["enableMotor"] == null ? false : (bool)jointValue["enableMotor"];
revoluteDef.motorSpeed = jsonToFloat("motorSpeed", jointValue);
revoluteDef.maxMotorTorque = jsonToFloat("maxMotorTorque", jointValue);
//jointDef = wheelDef = new b2WheelJointDef(); //JointFactory.CreateWheelJoint(world, bodyA, bodyB, localAnchorB, localAxisA);
//var localAnchorA = jsonToVec("anchorA", jointValue);
//var localAnchorB = (jsonToVec("anchorB", jointValue));
//var localAxisA = (jsonToVec("localAxisA", jointValue));
//var enableMotor = jointValue["enableMotor"] == null ? false : (bool)jointValue["enableMotor"];
//var motorSpeed = jsonToFloat("motorSpeed", jointValue);
//var maxMotorTorque = jsonToFloat("maxMotorTorque", jointValue);
//var frequencyHz = jsonToFloat("springFrequency", jointValue);
//var dampingRatio = jsonToFloat("springDampingRatio", jointValue);
//wheelDef.LocalAnchorA = localAnchorA;
//wheelDef.LocalAnchorB = localAnchorB;
//wheelDef.MotorEnabled = enableMotor;
//wheelDef.MotorSpeed = motorSpeed;
//wheelDef.SpringFrequencyHz = frequencyHz;
//wheelDef.MaxMotorTorque = maxMotorTorque;
//wheelDef.SpringDampingRatio = dampingRatio;
}
else if (type == "weld")
{
jointDef = weldDef = new b2WeldJointDef();
weldDef.localAnchorA = jsonToVec("anchorA", jointValue);
weldDef.localAnchorB = jsonToVec("anchorB", jointValue);
weldDef.referenceAngle = 0;
}
else if (type == "friction")
{
jointDef = frictionDef = new b2FrictionJointDef();
frictionDef.localAnchorA = jsonToVec("anchorA", jointValue);
frictionDef.localAnchorB = jsonToVec("anchorB", jointValue);
frictionDef.maxForce = jsonToFloat("maxForce", jointValue);
frictionDef.maxTorque = jsonToFloat("maxTorque", jointValue);
}
else if (type == "rope")
{
jointDef = ropeDef = new b2RopeJointDef();
ropeDef.localAnchorA = jsonToVec("anchorA", jointValue);
ropeDef.localAnchorB = jsonToVec("anchorB", jointValue);
ropeDef.maxLength = jsonToFloat("maxLength", jointValue);
}
//else if (type == "motor")
//{
// var maxForce = jsonToFloat("maxForce", jointValue);
// var maxMotorTorque = jsonToFloat("maxTorque", jointValue);
// var angularOffset = jsonToFloat("refAngle", jointValue);
// joint = motorDef = new MotorJoint(bodyA, bodyB);
// world.AddJoint(joint);
// motorDef.LinearOffset = jsonToVec("anchorA", jointValue);
// motorDef.MaxForce = maxForce;
// motorDef.MaxTorque = maxMotorTorque;
// motorDef.AngularOffset = angularOffset;
//}
if (null != jointDef)
{
// set features common to all joints
jointDef.BodyA = m_bodies[bodyIndexA];
jointDef.BodyB = m_bodies[bodyIndexB];
jointDef.CollideConnected = jointValue["collideConnected"] == null ? false : (bool)jointValue["collideConnected"];
joint = world.CreateJoint(jointDef);
if (type.Equals("mouse"))
((b2MouseJoint)joint).SetTarget(mouseJointTarget);
String jointName = jointValue["name"] == null ? "" : (string)jointValue["name"];
if (!jointName.Equals(""))
{
SetJointName(joint, jointName);
}
}
return joint;
}