/**
* @private
*/
public void SetPrevEdge(b2EdgeShape edge, b2Vec2 core, b2Vec2 cornerDir, bool convex)
{
m_prevEdge = edge;
m_coreV1 = core;
m_cornerDir1 = cornerDir;
m_cornerConvex1 = convex;
}
public virtual b2EdgeShape GetChildEdge(int index)
{
b2EdgeShape edge = new b2EdgeShape();
edge.ShapeType = b2ShapeType.e_edge;
edge.Radius = m_radius;
edge.Vertex1 = m_vertices[index + 0];
edge.Vertex2 = m_vertices[index + 1];
if (index > 0)
{
edge.Vertex0 = m_vertices[index - 1];
edge.HasVertex0 = true;
}
else
{
edge.Vertex0 = PrevVertex;
edge.HasVertex0 = m_hasPrevVertex;
}
if (index < m_count - 2)
{
edge.Vertex3 = m_vertices[index + 2];
edge.HasVertex3 = true;
}
else
{
edge.Vertex3 = NextVertex;
edge.HasVertex3 = m_hasNextVertex;
}
return(edge);
}
public VaryingRestitution()
{
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
{
b2CircleShape shape = new b2CircleShape();
shape.Radius = 1.0f;
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
fd.density = 1.0f;
float[] restitution = {0.0f, 0.1f, 0.3f, 0.5f, 0.75f, 0.9f, 1.0f};
for (int i = 0; i < 7; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-10.0f + 3.0f * i, 20.0f);
b2Body body = m_world.CreateBody(bd);
fd.restitution = restitution[i];
body.CreateFixture(fd);
}
}
}
public Breakable()
{
// Ground body
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
// Breakable dynamic body
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position = new b2Vec2(0.0f, 40.0f);
bd.angle = 0.25f * b2Settings.b2_pi;
m_body1 = m_world.CreateBody(bd);
m_shape1.SetAsBox(0.5f, 0.5f, new b2Vec2(-0.5f, 0.0f), 0.0f);
m_piece1 = m_body1.CreateFixture(m_shape1, 1.0f);
m_shape2.SetAsBox(0.5f, 0.5f, new b2Vec2(0.5f, 0.0f), 0.0f);
m_piece2 = m_body1.CreateFixture(m_shape2, 1.0f);
}
m_break = false;
m_broke = false;
}
void InitPhysics()
{
var gravity = new b2Vec2(0.0f, -10.0f);
world = new b2World(gravity);
world.SetAllowSleeping(true);
world.SetContinuousPhysics(true);
var def = new b2BodyDef();
def.allowSleep = true;
def.position = b2Vec2.Zero;
def.type = b2BodyType.b2_staticBody;
b2Body groundBody = world.CreateBody(def);
groundBody.SetActive(true);
b2EdgeShape groundBox = new b2EdgeShape();
groundBox.Set(b2Vec2.Zero, new b2Vec2(900, 100));
b2FixtureDef fd = new b2FixtureDef();
fd.friction = 0.3f;
fd.restitution = 0.1f;
fd.shape = groundBox;
groundBody.CreateFixture(fd);
}
public SphereStack()
{
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
{
b2CircleShape shape = new b2CircleShape();
shape.Radius = 1.0f;
for (int i = 0; i < e_count; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(0.0f, 4.0f + 3.0f * i);
m_bodies[i] = m_world.CreateBody(bd);
m_bodies[i].CreateFixture(shape, 1.0f);
m_bodies[i].LinearVelocity = new b2Vec2(0.0f, -50.0f);
}
}
}
/**
* @private
*/
public void SetNextEdge(b2EdgeShape edge, b2Vec2 core, b2Vec2 cornerDir, bool convex)
{
m_nextEdge = edge;
m_coreV2 = core;
m_cornerDir2 = cornerDir;
m_cornerConvex2 = convex;
}
public b2EdgeShape(b2EdgeShape e)
: base((b2Shape)e)
{
Vertex1 = e.Vertex1;
Vertex2 = e.Vertex2;
Vertex3 = e.Vertex3;
Vertex0 = e.Vertex0;
HasVertex0 = e.HasVertex0;
HasVertex3 = e.HasVertex3;
}
public b2EdgeShape(b2EdgeShape e)
: base((b2Shape)e)
{
Vertex1 = e.Vertex1;
Vertex2 = e.Vertex2;
Vertex3 = e.Vertex3;
Vertex0 = e.Vertex0;
HasVertex0 = e.HasVertex0;
HasVertex3 = e.HasVertex3;
}
public b2EdgeShape(b2EdgeShape e)
: base((b2Shape)e)
{
m_vertex1 = e.m_vertex1;
m_vertex2 = e.m_vertex2;
m_vertex3 = e.m_vertex3;
m_vertex0 = e.m_vertex0;
m_hasVertex0 = e.m_hasVertex0;
m_hasVertex3 = e.m_hasVertex3;
}
public b2EdgeShape(b2EdgeShape e)
: base((b2Shape)e)
{
m_vertex1 = e.m_vertex1;
m_vertex2 = e.m_vertex2;
m_vertex3 = e.m_vertex3;
m_vertex0 = e.m_vertex0;
m_hasVertex0 = e.m_hasVertex0;
m_hasVertex3 = e.m_hasVertex3;
}
public ContinuousTest()
{
{
b2BodyDef bd = new b2BodyDef();
bd.position.Set(0.0f, 0.0f);
b2Body body = m_world.CreateBody(bd);
b2EdgeShape edge = new b2EdgeShape();
edge.Set(new b2Vec2(-10.0f, 0.0f), new b2Vec2(10.0f, 0.0f));
body.CreateFixture(edge, 0.0f);
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.2f, 1.0f, new b2Vec2(0.5f, 1.0f), 0.0f);
body.CreateFixture(shape, 0.0f);
}
#if true
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(0.0f, 20.0f);
//bd.angle = 0.1f;
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(2.0f, 0.1f);
m_body = m_world.CreateBody(bd);
m_body.CreateFixture(shape, 1.0f);
m_angularVelocity = Rand.RandomFloat(-50.0f, 50.0f);
//m_angularVelocity = 46.661274f;
m_body.LinearVelocity = new b2Vec2(0.0f, -100.0f);
m_body.AngularVelocity = m_angularVelocity;
}
#else
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(0.0f, 2.0f);
b2Body body = m_world.CreateBody(bd);
b2CircleShape shape = new b2CircleShape();
shape.Position = b2Vec2.Zero;
shape.Radius = 0.5f;
body.CreateFixture(shape, 1.0f);
bd.bullet = true;
bd.position.Set(0.0f, 10.0f);
body = m_world.CreateBody(bd);
body.CreateFixture(shape, 1.0f);
body.LinearVelocity = new b2Vec2(0.0f, -100.0f);
}
#endif
}
public Pulleys()
{
float y = 16.0f;
float L = 12.0f;
float a = 1.0f;
float b = 2.0f;
b2Body ground = null;
{
b2BodyDef bd = new b2BodyDef();
ground = m_world.CreateBody(bd);
b2EdgeShape edge = new b2EdgeShape();
edge.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
//ground->CreateFixture(&shape, 0.0f);
b2CircleShape circle = new b2CircleShape();
circle.Radius = 2.0f;
circle.Position = new b2Vec2(-10.0f, y + b + L);
ground.CreateFixture(circle, 0.0f);
circle.Position = new b2Vec2(10.0f, y + b + L);
ground.CreateFixture(circle, 0.0f);
}
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(a, b);
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
//bd.fixedRotation = true;
bd.position.Set(-10.0f, y);
b2Body body1 = m_world.CreateBody(bd);
body1.CreateFixture(shape, 5.0f);
bd.position.Set(10.0f, y);
b2Body body2 = m_world.CreateBody(bd);
body2.CreateFixture(shape, 5.0f);
b2PulleyJointDef pulleyDef = new b2PulleyJointDef();
b2Vec2 anchor1 = new b2Vec2(-10.0f, y + b);
b2Vec2 anchor2 = new b2Vec2(10.0f, y + b);
b2Vec2 groundAnchor1 = new b2Vec2(-10.0f, y + b + L);
b2Vec2 groundAnchor2 = new b2Vec2(10.0f, y + b + L);
pulleyDef.Initialize(body1, body2, groundAnchor1, groundAnchor2, anchor1, anchor2, 1.5f);
m_joint1 = (b2PulleyJoint) m_world.CreateJoint(pulleyDef);
}
}
public SensorTest()
{
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
{
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
#if false
{
b2FixtureDef sd = new b2FixtureDef();
sd.SetAsBox(10.0f, 2.0f, new b2Vec2(0.0f, 20.0f), 0.0f);
sd.isSensor = true;
m_sensor = ground.CreateFixture(sd);
}
#else
{
b2CircleShape shape = new b2CircleShape();
shape.Radius = 5.0f;
shape.Position = new b2Vec2(0.0f, 10.0f);
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
fd.isSensor = true;
m_sensor = ground.CreateFixture(fd);
}
#endif
}
{
b2CircleShape shape = new b2CircleShape();
shape.Radius = 1.0f;
for (int i = 0; i < e_count; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-10.0f + 3.0f * i, 20.0f);
bd.userData = i; // m_touching[i];
m_touching[i] = false;
m_bodies[i] = m_world.CreateBody(bd);
m_bodies[i].CreateFixture(shape, 1.0f);
}
}
}
public Confined()
{
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
// Floor
shape.Set(new b2Vec2(-10.0f, 0.0f), new b2Vec2(10.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
// Left wall
shape.Set(new b2Vec2(-10.0f, 0.0f), new b2Vec2(-10.0f, 20.0f));
ground.CreateFixture(shape, 0.0f);
// Right wall
shape.Set(new b2Vec2(10.0f, 0.0f), new b2Vec2(10.0f, 20.0f));
ground.CreateFixture(shape, 0.0f);
// Roof
shape.Set(new b2Vec2(-10.0f, 20.0f), new b2Vec2(10.0f, 20.0f));
ground.CreateFixture(shape, 0.0f);
}
float radius = 0.5f;
b2CircleShape shape1 = new b2CircleShape();
shape1.Position = b2Vec2.Zero;
shape1.Radius = radius;
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape1;
fd.density = 1.0f;
fd.friction = 0.1f;
for (int j = 0; j < e_columnCount; ++j)
{
for (int i = 0; i < e_rowCount; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-10.0f + (2.1f * j + 1.0f + 0.01f * i) * radius, (2.0f * i + 1.0f) * radius);
b2Body body = m_world.CreateBody(bd);
body.CreateFixture(fd);
}
}
m_world.Gravity = new b2Vec2(0.0f, 0.0f);
}
//public const int e_columnCount = 1;
//public const int e_rowCount = 1;
public VerticalStack()
{
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
shape.Set(new b2Vec2(20.0f, 0.0f), new b2Vec2(20.0f, 20.0f));
ground.CreateFixture(shape, 0.0f);
}
float[] xs = {0.0f, -10.0f, -5.0f, 5.0f, 10.0f};
for (int j = 0; j < e_columnCount; ++j)
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.5f, 0.5f);
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
fd.density = 1.0f;
fd.friction = 0.3f;
for (int i = 0; i < e_rowCount; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
int n = j * e_rowCount + i;
Debug.Assert(n < e_rowCount * e_columnCount);
m_indices[n] = n;
bd.userData = m_indices[n];
float x = 0.0f;
//float32 x = RandomFloat(-0.02f, 0.02f);
//float32 x = i % 2 == 0 ? -0.025f : 0.025f;
bd.position.Set(xs[j] + x, 0.752f + 1.54f * i);
b2Body body = m_world.CreateBody(bd);
m_bodies[n] = body;
body.CreateFixture(fd);
}
}
m_bullet = null;
}
public Prismatic()
{
b2Body ground = null;
{
b2BodyDef bd = new b2BodyDef();
ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(2.0f, 0.5f);
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-10.0f, 10.0f);
bd.angle = 0.5f * b2Settings.b2_pi;
bd.allowSleep = false;
b2Body body = m_world.CreateBody(bd);
body.CreateFixture(shape, 5.0f);
b2PrismaticJointDef pjd = new b2PrismaticJointDef();
// Bouncy limit
b2Vec2 axis = new b2Vec2(2.0f, 1.0f);
axis.Normalize();
pjd.Initialize(ground, body, new b2Vec2(0.0f, 0.0f), axis);
// Non-bouncy limit
//pjd.Initialize(ground, body, b2Vec2(-10.0f, 10.0f), b2Vec2(1.0f, 0.0f));
pjd.motorSpeed = 10.0f;
pjd.maxMotorForce = 10000.0f;
pjd.enableMotor = true;
pjd.lowerTranslation = 0.0f;
pjd.upperTranslation = 20.0f;
pjd.enableLimit = true;
m_joint = (b2PrismaticJoint) m_world.CreateJoint(pjd);
}
}
public OneSidedPlatform()
{
// Ground
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-20.0f, 0.0f), new b2Vec2(20.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
// Platform
{
b2BodyDef bd = new b2BodyDef();
bd.position.Set(0.0f, 10.0f);
b2Body body = m_world.CreateBody(bd);
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(3.0f, 0.5f);
m_platform = body.CreateFixture(shape, 0.0f);
m_bottom = 10.0f - 0.5f;
m_top = 10.0f + 0.5f;
}
// Actor
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(0.0f, 12.0f);
b2Body body = m_world.CreateBody(bd);
m_radius = 0.5f;
b2CircleShape shape = new b2CircleShape();
shape.Radius = m_radius;
m_character = body.CreateFixture(shape, 20.0f);
body.LinearVelocity = new b2Vec2(0.0f, -50.0f);
m_state = State.e_unknown;
}
}
public Chain()
{
b2Body ground = null;
{
b2BodyDef bd = new b2BodyDef();
ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.6f, 0.125f);
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
fd.density = 20.0f;
fd.friction = 0.2f;
b2RevoluteJointDef jd = new b2RevoluteJointDef();
jd.CollideConnected = false;
const float y = 25.0f;
b2Body prevBody = ground;
for (int i = 0; i < 30; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(0.5f + i, y);
b2Body body = m_world.CreateBody(bd);
body.CreateFixture(fd);
b2Vec2 anchor = new b2Vec2(i, y);
jd.Initialize(prevBody, body, anchor);
m_world.CreateJoint(jd);
prevBody = body;
}
}
}
public CircleBenchmarkTest()
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
// Floor
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
// Left wall
shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(-40.0f, 45.0f));
ground.CreateFixture(shape, 0.0f);
// Right wall
shape = new b2EdgeShape();
shape.Set(new b2Vec2(40.0f, 0.0f), new b2Vec2(40.0f, 45.0f));
ground.CreateFixture(shape, 0.0f);
// Roof
shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 45.0f), new b2Vec2(40.0f, 45.0f));
ground.CreateFixture(shape, 0.0f);
var sphere = new b2CircleShape();
sphere.Radius = 1.0f;
for (int i = 0; i < XCount; i++)
{
for (int j = 0; j < YCount; ++j)
{
bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-38f + 2.1f * i, 2.0f + 2.0f * j);
var body = m_world.CreateBody(bd);
body.CreateFixture(sphere, 1.0f);
}
}
}
public BulletTest()
{
{
b2BodyDef bd = new b2BodyDef();
bd.position.Set(0.0f, 0.0f);
b2Body body = m_world.CreateBody(bd);
b2EdgeShape edge = new b2EdgeShape();
edge.Set(new b2Vec2(-10.0f, 0.0f), new b2Vec2(10.0f, 0.0f));
body.CreateFixture(edge, 0.0f);
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.2f, 1.0f, new b2Vec2(0.5f, 1.0f), 0.0f);
body.CreateFixture(shape, 0.0f);
}
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(0.0f, 4.0f);
b2PolygonShape box = new b2PolygonShape();
box.SetAsBox(2.0f, 0.1f);
m_body = m_world.CreateBody(bd);
m_body.CreateFixture(box, 1.0f);
box.SetAsBox(0.25f, 0.25f);
//m_x = RandomFloat(-1.0f, 1.0f);
m_x = 0.20352793f;
bd.position.Set(m_x, 10.0f);
bd.bullet = true;
m_bullet = m_world.CreateBody(bd);
m_bullet.CreateFixture(box, 100.0f);
m_bullet.LinearVelocity = new b2Vec2(0.0f, -50.0f);
}
}
public Pyramid()
{
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
{
float a = 0.5f;
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(a, a);
b2Vec2 x = new b2Vec2(-7.0f, 0.75f);
b2Vec2 y;
b2Vec2 deltaX = new b2Vec2(0.5625f, 1.25f);
b2Vec2 deltaY = new b2Vec2(1.125f, 0.0f);
for (int i = 0; i < e_count; ++i)
{
y = x;
for (int j = i; j < e_count; ++j)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position = y;
b2Body body = m_world.CreateBody(bd);
body.CreateFixture(shape, 5.0f);
y += deltaY;
}
x += deltaX;
}
}
}
public override bool RayCast(out b2RayCastOutput output, b2RayCastInput input, ref b2Transform xf, int childIndex)
{
b2EdgeShape edgeShape = new b2EdgeShape();
output = b2RayCastOutput.Zero;
int i1 = childIndex;
int i2 = childIndex + 1;
if (i2 == Count)
{
i2 = 0;
}
edgeShape.Vertex1 = Vertices[i1];
edgeShape.Vertex2 = Vertices[i2];
b2RayCastOutput co = b2RayCastOutput.Zero;
bool b = edgeShape.RayCast(out co, input, ref xf, 0);
output = co;
return(b);
}
public ShapeEditing()
{
{
b2BodyDef bd1 = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd1);
b2EdgeShape shape1 = new b2EdgeShape();
shape1.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape1, 0.0f);
}
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(0.0f, 10.0f);
m_body = m_world.CreateBody(bd);
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(4.0f, 4.0f, new b2Vec2(0.0f, 0.0f), 0.0f);
m_fixture1 = m_body.CreateFixture(shape, 10.0f);
m_fixture2 = null;
m_sensor = false;
}
/// Compute the collision manifold between an edge and a circle.
public static void b2CollideEdgeAndPolygon(ref b2Manifold manifold,
b2EdgeShape edgeA, ref b2Transform xfA,
b2PolygonShape polygonB, ref b2Transform xfB)
{
b2EPCollider b = new b2EPCollider();
b.Collide(ref manifold, edgeA, ref xfA, polygonB, ref xfB);
}
/// Compute the collision manifold between an edge and a circle.
public static void b2CollideEdgeAndCircle(ref b2Manifold manifold,
b2EdgeShape edgeA, ref b2Transform xfA,
b2CircleShape circleB, ref b2Transform xfB)
{
manifold.pointCount = 0;
// Compute circle in frame of edge
b2Vec2 Q = b2Math.b2MulT(xfA, b2Math.b2Mul(xfB, circleB.Position));
b2Vec2 A = edgeA.Vertex1, B = edgeA.Vertex2;
b2Vec2 e = B - A;
b2Vec2 diff;
// Barycentric coordinates
diff = B - Q;
float u = b2Math.b2Dot(ref e, ref diff); // B - Q);
diff = Q - A;
float v = b2Math.b2Dot(ref e, ref diff); // Q - A);
float radius = edgeA.Radius + circleB.Radius;
b2ContactFeature cf = b2ContactFeature.Zero;
cf.indexB = 0;
cf.typeB = b2ContactFeatureType.e_vertex;
// Region A
if (v <= 0.0f)
{
b2Vec2 P = A;
b2Vec2 d = Q - P;
float dd = d.LengthSquared; // b2Math.b2Dot(d, d);
if (dd > radius * radius)
{
return;
}
// Is there an edge connected to A?
if (edgeA.HasVertex0)
{
b2Vec2 A1 = edgeA.Vertex0;
b2Vec2 B1 = A;
b2Vec2 e1 = B1 - A1;
diff = B1 - Q;
float u1 = b2Math.b2Dot(ref e1, ref diff);
// Is the circle in Region AB of the previous edge?
if (u1 > 0.0f)
{
return;
}
}
cf.indexA = 0;
cf.typeA = b2ContactFeatureType.e_vertex;
manifold.pointCount = 1;
manifold.type = b2ManifoldType.e_circles;
manifold.localNormal.SetZero();
manifold.localPoint = P;
manifold.points[0].id.key = 0;
manifold.points[0].id.Set(cf);
manifold.points[0].localPoint = circleB.Position;
return;
}
// Region B
if (u <= 0.0f)
{
b2Vec2 P = B;
b2Vec2 d = Q - P;
float dd = d.LengthSquared; // b2Math.b2Dot(d, d);
if (dd > radius * radius)
{
return;
}
// Is there an edge connected to B?
if (edgeA.HasVertex3)
{
b2Vec2 B2 = edgeA.Vertex3;
b2Vec2 A2 = B;
b2Vec2 e2 = B2 - A2;
diff = Q - A2;
float v2 = b2Math.b2Dot(ref e2, ref diff);
// Is the circle in Region AB of the next edge?
if (v2 > 0.0f)
{
return;
}
}
cf.indexA = 1;
cf.typeA = b2ContactFeatureType.e_vertex;
manifold.pointCount = 1;
manifold.type = b2ManifoldType.e_circles;
manifold.localNormal.SetZero();
manifold.localPoint = P;
manifold.points[0].id.key = 0;
manifold.points[0].id.Set(cf);
manifold.points[0].localPoint = circleB.Position;
return;
}
// Region AB
float den = e.Length; // b2Math.b2Dot(e, e);
System.Diagnostics.Debug.Assert(den > 0.0f);
b2Vec2 xP = (1.0f / den) * (u * A + v * B);
b2Vec2 xd = Q - xP;
float xdd = xd.LengthSquared; // b2Math.b2Dot(xd, xd);
if (xdd > radius * radius)
{
return;
}
b2Vec2 n = b2Vec2.Zero; // new b2Vec2(-e.y, e.x);
n.m_x = -e.y;
n.m_y = e.x;
diff = Q - A;
if (b2Math.b2Dot(ref n, ref diff) < 0.0f)
{
// n.Set(-n.x, -n.y);
n.Set(-n.m_x, -n.m_y);
}
n.Normalize();
cf.indexA = 0;
cf.typeA = b2ContactFeatureType.e_face;
manifold.pointCount = 1;
manifold.type = b2ManifoldType.e_faceA;
manifold.localNormal = n;
manifold.localPoint = A;
manifold.points[0].id.key = 0;
manifold.points[0].id.Set(cf);
manifold.points[0].localPoint = circleB.Position;
}
public override b2Shape Clone()
{
b2EdgeShape clone = new b2EdgeShape(this);
return clone;
}
void InitPhysics()
{
CCSize s = Layer.VisibleBoundsWorldspace.Size;
var gravity = new b2Vec2 (0.0f, -10.0f);
world = new b2World (gravity);
world.SetAllowSleeping (true);
world.SetContinuousPhysics (true);
var def = new b2BodyDef ();
def.allowSleep = true;
def.position = b2Vec2.Zero;
def.type = b2BodyType.b2_staticBody;
b2Body groundBody = world.CreateBody (def);
groundBody.SetActive (true);
b2EdgeShape groundBox = new b2EdgeShape ();
groundBox.Set (b2Vec2.Zero, new b2Vec2 (s.Width / PTM_RATIO, 0));
b2FixtureDef fd = new b2FixtureDef ();
fd.shape = groundBox;
groundBody.CreateFixture (fd);
}
public override bool RayCast(out b2RayCastOutput output, b2RayCastInput input,
b2Transform xf, int childIndex)
{
b2EdgeShape edgeShape = new b2EdgeShape();
output = b2RayCastOutput.Zero;
int i1 = childIndex;
int i2 = childIndex + 1;
if (i2 == m_count)
{
i2 = 0;
}
edgeShape.Vertex1 = m_vertices[i1];
edgeShape.Vertex2 = m_vertices[i2];
b2RayCastOutput co = b2RayCastOutput.Zero;
bool b = edgeShape.RayCast(out co, input, xf, 0);
output = co;
return (b);
}
public virtual b2Shape Clone()
{
b2EdgeShape clone = new b2EdgeShape(this);
return(clone);
}
public Web()
{
b2Body ground = null;
{
b2BodyDef bd = new b2BodyDef();
ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
ground.CreateFixture(shape, 0.0f);
}
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.5f, 0.5f);
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-5.0f, 5.0f);
m_bodies[0] = m_world.CreateBody(bd);
m_bodies[0].CreateFixture(shape, 5.0f);
bd.position.Set(5.0f, 5.0f);
m_bodies[1] = m_world.CreateBody(bd);
m_bodies[1].CreateFixture(shape, 5.0f);
bd.position.Set(5.0f, 15.0f);
m_bodies[2] = m_world.CreateBody(bd);
m_bodies[2].CreateFixture(shape, 5.0f);
bd.position.Set(-5.0f, 15.0f);
m_bodies[3] = m_world.CreateBody(bd);
m_bodies[3].CreateFixture(shape, 5.0f);
b2DistanceJointDef jd = new b2DistanceJointDef();
b2Vec2 p1 = new b2Vec2();
b2Vec2 p2 = new b2Vec2();
b2Vec2 d = new b2Vec2();
jd.frequencyHz = 2.0f;
jd.dampingRatio = 0.0f;
jd.BodyA = ground;
jd.BodyB = m_bodies[0];
jd.localAnchorA.Set(-10.0f, 0.0f);
jd.localAnchorB.Set(-0.5f, -0.5f);
p1 = jd.BodyA.GetWorldPoint(jd.localAnchorA);
p2 = jd.BodyB.GetWorldPoint(jd.localAnchorB);
d = p2 - p1;
jd.length = d.Length;
m_joints[0] = m_world.CreateJoint(jd);
jd.BodyA = ground;
jd.BodyB = m_bodies[1];
jd.localAnchorA.Set(10.0f, 0.0f);
jd.localAnchorB.Set(0.5f, -0.5f);
p1 = jd.BodyA.GetWorldPoint(jd.localAnchorA);
p2 = jd.BodyB.GetWorldPoint(jd.localAnchorB);
d = p2 - p1;
jd.length = d.Length;
m_joints[1] = m_world.CreateJoint(jd);
jd.BodyA = ground;
jd.BodyB = m_bodies[2];
jd.localAnchorA.Set(10.0f, 20.0f);
jd.localAnchorB.Set(0.5f, 0.5f);
p1 = jd.BodyA.GetWorldPoint(jd.localAnchorA);
p2 = jd.BodyB.GetWorldPoint(jd.localAnchorB);
d = p2 - p1;
jd.length = d.Length;
m_joints[2] = m_world.CreateJoint(jd);
jd.BodyA = ground;
jd.BodyB = m_bodies[3];
jd.localAnchorA.Set(-10.0f, 20.0f);
jd.localAnchorB.Set(-0.5f, 0.5f);
p1 = jd.BodyA.GetWorldPoint(jd.localAnchorA);
p2 = jd.BodyB.GetWorldPoint(jd.localAnchorB);
d = p2 - p1;
jd.length = d.Length;
m_joints[3] = m_world.CreateJoint(jd);
jd.BodyA = m_bodies[0];
jd.BodyB = m_bodies[1];
jd.localAnchorA.Set(0.5f, 0.0f);
jd.localAnchorB.Set(-0.5f, 0.0f);
;
p1 = jd.BodyA.GetWorldPoint(jd.localAnchorA);
p2 = jd.BodyB.GetWorldPoint(jd.localAnchorB);
d = p2 - p1;
jd.length = d.Length;
m_joints[4] = m_world.CreateJoint(jd);
jd.BodyA = m_bodies[1];
jd.BodyB = m_bodies[2];
jd.localAnchorA.Set(0.0f, 0.5f);
jd.localAnchorB.Set(0.0f, -0.5f);
p1 = jd.BodyA.GetWorldPoint(jd.localAnchorA);
p2 = jd.BodyB.GetWorldPoint(jd.localAnchorB);
d = p2 - p1;
jd.length = d.Length;
m_joints[5] = m_world.CreateJoint(jd);
jd.BodyA = m_bodies[2];
jd.BodyB = m_bodies[3];
jd.localAnchorA.Set(-0.5f, 0.0f);
jd.localAnchorB.Set(0.5f, 0.0f);
p1 = jd.BodyA.GetWorldPoint(jd.localAnchorA);
p2 = jd.BodyB.GetWorldPoint(jd.localAnchorB);
d = p2 - p1;
jd.length = d.Length;
m_joints[6] = m_world.CreateJoint(jd);
jd.BodyA = m_bodies[3];
jd.BodyB = m_bodies[0];
jd.localAnchorA.Set(0.0f, -0.5f);
jd.localAnchorB.Set(0.0f, 0.5f);
p1 = jd.BodyA.GetWorldPoint(jd.localAnchorA);
p2 = jd.BodyB.GetWorldPoint(jd.localAnchorB);
d = p2 - p1;
jd.length = d.Length;
m_joints[7] = m_world.CreateJoint(jd);
}
}
public EdgeShapes()
{
// Ground body
{
b2BodyDef bd = new b2BodyDef();
b2Body ground = m_world.CreateBody(bd);
float x1 = -20.0f;
float y1 = 2.0f * (float) Math.Cos(x1 / 10.0f * b2Settings.b2_pi);
for (int i = 0; i < 80; ++i)
{
float x2 = x1 + 0.5f;
float y2 = 2.0f * (float) Math.Cos(x2 / 10.0f * b2Settings.b2_pi);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(x1, y1), new b2Vec2(x2, y2));
ground.CreateFixture(shape, 0.0f);
x1 = x2;
y1 = y2;
}
}
{
b2Vec2[] vertices = new b2Vec2[3];
vertices[0].Set(-0.5f, 0.0f);
vertices[1].Set(0.5f, 0.0f);
vertices[2].Set(0.0f, 1.5f);
m_polygons[0] = new b2PolygonShape();
m_polygons[0].Set(vertices, 3);
}
{
b2Vec2[] vertices = new b2Vec2[3];
vertices[0].Set(-0.1f, 0.0f);
vertices[1].Set(0.1f, 0.0f);
vertices[2].Set(0.0f, 1.5f);
m_polygons[1] = new b2PolygonShape();
m_polygons[1].Set(vertices, 3);
}
{
float w = 1.0f;
float b = w / (2.0f + b2Math.b2Sqrt(2.0f));
float s = b2Math.b2Sqrt(2.0f) * b;
b2Vec2[] vertices = new b2Vec2[8];
vertices[0].Set(0.5f * s, 0.0f);
vertices[1].Set(0.5f * w, b);
vertices[2].Set(0.5f * w, b + s);
vertices[3].Set(0.5f * s, w);
vertices[4].Set(-0.5f * s, w);
vertices[5].Set(-0.5f * w, b + s);
vertices[6].Set(-0.5f * w, b);
vertices[7].Set(-0.5f * s, 0.0f);
m_polygons[2] = new b2PolygonShape();
m_polygons[2].Set(vertices, 8);
}
{
m_polygons[3] = new b2PolygonShape();
m_polygons[3].SetAsBox(0.5f, 0.5f);
}
{
m_circle.Radius = 0.5f;
}
m_bodyIndex = 0;
m_angle = 0.0f;
}
public virtual b2EdgeShape GetChildEdge(int index)
{
b2EdgeShape edge = new b2EdgeShape();
edge.ShapeType = b2ShapeType.e_edge;
edge.Radius = m_radius;
edge.Vertex1 = m_vertices[index + 0];
edge.Vertex2 = m_vertices[index + 1];
if (index > 0)
{
edge.Vertex0 = m_vertices[index - 1];
edge.HasVertex0 = true;
}
else
{
edge.Vertex0 = PrevVertex;
edge.HasVertex0 = m_hasPrevVertex;
}
if (index < m_count - 2)
{
edge.Vertex3 = m_vertices[index + 2];
edge.HasVertex3 = true;
}
else
{
edge.Vertex3 = NextVertex;
edge.HasVertex3 = m_hasNextVertex;
}
return (edge);
}
protected override void AddedToScene()
{
base.AddedToScene();
layerInstance = this;
//get screen size
screenSize = Window.WindowSizeInPixels; //CCDirector::sharedDirector()->getWinSize();
//INITIAL VARIABLES.... (D O N T E D I T )
// enable touches
#if XBOX || OUYA
TouchEnabled = false;
GamePadEnabled = true;
#else
//TouchEnabled = true;
CCEventListenerTouchAllAtOnce tListener = new CCEventListenerTouchAllAtOnce();
tListener.OnTouchesBegan = TouchesBegan;
//tListener.OnTouchesCancelled = TouchesCancelled;
tListener.OnTouchesEnded = TouchesEnded;
tListener.OnTouchesMoved = TouchesMoved;
AddEventListener(tListener, this);
#endif
// enable accelerometer
//AccelerometerEnabled = false;
#if iPHONE || iOS
IS_IPAD = MonoTouch.UIKit.UIDevice.CurrentDevice.UserInterfaceIdiom
== MonoTouch.UIKit.UIUserInterfaceIdiom.Pad;
IS_RETINA = MonoTouch.UIKit.UIScreen.MainScreen.Bounds.Height
* MonoTouch.UIKit.UIScreen.MainScreen.Scale >= 1136;
#endif
#if WINDOWS || MACOS || MONOMAC || LINUX || OUYA || XBOX
IS_IPAD = true;
IS_RETINA = true;
#endif
IS_IPHONE = !IS_IPAD;
// ask director for the window size
screenWidth = (int)screenSize.Width;
screenHeight = (int)screenSize.Height;
throwInProgress = false; //is a throw currently in progress, as in, is a ninja in midair (mostly used to prevent tossing two ninjas, one right after another)
areWeInTheStartingPosition = true; //is the world back at 0 on the X axis (if yes, then we can put a ninja in the sling)
throwCount = 0;
dotTotalOnOddNumberedTurn = 0;
dotTotalOnEvenNumberedTurn = 0;
currentLevel = GameData.SharedData.Level; // use currentLevel = 0 for testing new shapes, will call [self buildLevelWithAllShapes];
pointTotalThisRound = 0;
pointsToPassLevel = GameData.SharedData.PointsToPassLevel;
bonusPerExtraNinja = GameData.SharedData.BonusPerExtraNinja;
CCLog.Log(string.Format("The level is {0}, you need {1} to move up a level", currentLevel, pointsToPassLevel));
//PREFERENCE VARIABLES....
openWithMenuInsteadOfGame = false; // start with the menu opening the game
continuePanningScreenOnFingerRelease = true; // if the screen panning is midway between either the sling or targets, when you release your finger the screen will continue panning the last direction it moved (jumpy on iPhone if set to NO)
reverseHowFingerPansScreen = false; //switch to yes to reverse.
topRightTouchEnablesDebugMode = true; //SET TO NO IN FINAL BUILD
useImagesForPointScoreLabels = true; //IF NO, means you use Marker Felt text for scores
//set up background art
backgroundLayerClouds = new CCSprite(GameData.SharedData.BackgroundCloudsFileName); // will return the background clouds file for a particular level
AddChild(backgroundLayerClouds, Constants.DepthClouds);
backgroundLayerHills = new CCSprite(GameData.SharedData.BackgroundHillsFileName); // will return the background hills file for a particular level
AddChild(backgroundLayerHills, Constants.DepthHills);
backgroundLayerHills.ScaleX = 1.05f;
slingShotFront = new CCSprite("slingshot_front");
AddChild(slingShotFront, Constants.DepthSlingShotFront);
strapFront = new CCSprite("strap");
AddChild(strapFront, Constants.DepthStrapFront);
strapBack = new CCSprite("strapBack");
AddChild(strapBack, Constants.DepthStrapBack);
strapEmpty = new CCSprite("strapEmpty");
AddChild(strapEmpty, Constants.DepthStrapBack);
strapBack.Visible = false; //visible only when stretching
strapFront.Visible = false; //visible only when stretching
//setup positions and variables for iPad devices or iPhones
if (IS_IPAD)
{
areWeOnTheIPad = true;
//vars
maxStretchOfSlingShot = 75; //best to leave as is, since this value ties in closely to the image size of strap.png. (should be 1/4 the size of the source image)
multipyThrowPower = 1; // fine tune how powerful the sling shot is. Range is probably best between .5 to 1.5, currently for the iPad 1.0 is good
worldMaxHorizontalShift = -(screenWidth); // This determines how far the user can slide left or right to see the entire board. Always a negative number.
maxScaleDownValue = 1.0f; //dont change
scaleAmount = 0; // increment to change the scale of the entire world when panning
initialPanAmount = 30; //how fast the screen pan starts
extraAmountOnPanBack = 10; // I like a faster pan back. Adding a bit more
adjustY = 0; // best to leave at 0 for iPad (moves the world down when panning)
//background stuff
backgroundLayerClouds.Position = new CCPoint(screenWidth, screenHeight / 2);
backgroundLayerHills.Position = new CCPoint(screenWidth, screenHeight / 2);
if (!IS_RETINA)
{
//non retina adjustment
}
else
{
//retina adjustment
backgroundLayerClouds.Scale = 2.0f;
backgroundLayerHills.Scale = 2.0f;
}
menuStartPosition = new CCPoint(130, screenSize.Height - 24);
currentScoreLabelStartPosition = new CCPoint(200, screenSize.Height - 60);
highScoreLabelStartPosition = new CCPoint(200, screenSize.Height - 80);
fontSizeForScore = 22;
//ground plane and platform
groundPlaneStartPosition = new CCPoint(screenWidth, 50);
platformStartPosition = new CCPoint(340, 190);
//sling shot
slingShotCenterPosition = new CCPoint(370, 255);
slingShotFront.Position = new CCPoint(374, 240);
strapFront.Position = new CCPoint(slingShotCenterPosition.X, slingShotCenterPosition.Y);
strapBack.Position = new CCPoint(slingShotCenterPosition.X + 33, slingShotCenterPosition.Y - 10);
strapEmpty.Position = new CCPoint(378, 235);
//ninja
ninjaStartPosition1 = new CCPoint(380, 250);
ninjaStartPosition2 = new CCPoint(300, 155);
ninjaStartPosition3 = new CCPoint(260, 155);
ninjaStartPosition4 = new CCPoint(200, 120);
ninjaStartPosition5 = new CCPoint(160, 120);
}
else if (IS_IPHONE)
{
//CCLOG (@"this is an iphone");
areWeOnTheIPad = false;
//vars
maxStretchOfSlingShot = 75; //best to leave as is, since this value ties in closely to the image size of strap.png. (should be 1/4 the size of the source image)
multipyThrowPower = 1.0f; // fine tune how powerful the sling shot is. Range is probably best between .5 to 1.5, and a little goes a long way
worldMaxHorizontalShift = -(screenWidth); // This determines how far the user can slide left or right to see the entire board. Always a negative number
maxScaleDownValue = 0.65f; //range should probably be between 0.75 and 1.0;
scaleAmount = .01f; // increment to change the scale of the entire world when panning
adjustY = -34;
initialPanAmount = 20; //how fast the screen pan starts
extraAmountOnPanBack = 0; // best to leave at 0 on iPhone
//background stuff
if (!IS_RETINA)
{
//non retina adjustment
backgroundLayerClouds.Position = new CCPoint(screenWidth, 192);
backgroundLayerClouds.Scale = .7f;
backgroundLayerHills.Position = new CCPoint(screenWidth, 245);
backgroundLayerHills.Scale = .7f;
}
else
{
//retina adjustment
backgroundLayerClouds.Position = new CCPoint(screenWidth, 192);
backgroundLayerClouds.Scale = 1.7f;
backgroundLayerHills.Position = new CCPoint(screenWidth, 265);
backgroundLayerHills.Scale = 1.7f;
}
menuStartPosition = new CCPoint(70, screenSize.Height - 17);
currentScoreLabelStartPosition = new CCPoint(140, screenSize.Height - 50); //score label
highScoreLabelStartPosition = new CCPoint(140, screenSize.Height - 70);
fontSizeForScore = 18;
//ground plane and platform
groundPlaneStartPosition = new CCPoint(screenWidth, -25);
platformStartPosition = new CCPoint(130, 120);
//sling shot
slingShotCenterPosition = new CCPoint(160, 185);
slingShotFront.Position = new CCPoint(164, 170);
strapFront.Position = new CCPoint(slingShotCenterPosition.X, slingShotCenterPosition.Y);
strapBack.Position = new CCPoint(slingShotCenterPosition.X + 33, slingShotCenterPosition.Y - 10);
strapEmpty.Position = new CCPoint(168, 163);
//ninja
ninjaStartPosition1 = new CCPoint(170, 175);
ninjaStartPosition2 = new CCPoint(110, 82);
ninjaStartPosition3 = new CCPoint(65, 82);
ninjaStartPosition4 = new CCPoint(90, 65);
ninjaStartPosition5 = new CCPoint(43, 65);
}
SetUpParticleSystemSun();
CCMenuItemImage button1 = new CCMenuItemImage("gameMenu", "gameMenu", ShowMenu);
MenuButton = new CCMenu(button1);
MenuButton.Position = menuStartPosition;
AddChild(MenuButton, Constants.DepthScore);
// assign CCPoints to keep track of the starting positions of objects that move relative to the entire layer.
hillsLayerStartPosition = backgroundLayerHills.Position;
cloudLayerStartPosition = backgroundLayerClouds.Position;
// Define the gravity vector.
yAxisGravity = -9.81f;
b2Vec2 gravity = b2Vec2.Zero;
gravity.Set(0.0f, yAxisGravity);
// Construct a world object, which will hold and simulate the rigid bodies.
world = new b2World(gravity);
world.AllowSleep = false;
world.SetContinuousPhysics(true);
//EnableDebugMode();
// Define the ground body.
var groundBodyDef = new b2BodyDef(); // Make sure we call
groundBodyDef.position.Set(0, 0); // bottom-left corner
// Call the body factory which allocates memory for the ground body
// from a pool and creates the ground box shape (also from a pool).
// The body is also added to the world.
b2Body groundBody = world.CreateBody(groundBodyDef);
// Define the ground box shape.
b2EdgeShape groundBox = new b2EdgeShape();
int worldMaxWidth = screenWidth * 4; //If you ever want the BOX2D world width to be more than it is then increase this (currently, this should be plenty of extra space)
int worldMaxHeight = screenHeight * 3; //If you ever want the BOX2D world height to be more than it is then increase this (currently, this should be plenty of extra space)
// bottom
groundBox.Set(new b2Vec2(-4, 0), new b2Vec2(worldMaxWidth / Constants.PTM_RATIO, 0));
groundBody.CreateFixture(groundBox, 0);
// top
groundBox.Set(new b2Vec2(-4, worldMaxHeight / Constants.PTM_RATIO), new b2Vec2(worldMaxWidth / Constants.PTM_RATIO, worldMaxHeight / Constants.PTM_RATIO));
groundBody.CreateFixture(groundBox, 0);
// left
groundBox.Set(new b2Vec2(-4, worldMaxHeight / Constants.PTM_RATIO), new b2Vec2(-4, 0));
groundBody.CreateFixture(groundBox, 0);
// right
groundBox.Set(new b2Vec2(worldMaxWidth / Constants.PTM_RATIO, worldMaxHeight / Constants.PTM_RATIO), new b2Vec2(worldMaxWidth / Constants.PTM_RATIO, 0));
groundBody.CreateFixture(groundBox, 0);
//Contact listener
contactListener = new ContactListener();
world.SetContactListener(contactListener);
//Set up the ground plane
theGroundPlane = new GroundPlane(world, groundPlaneStartPosition, GameData.SharedData.GroundPlaneFileName);
AddChild(theGroundPlane, Constants.DepthFloor);
//Set up the starting platform
thePlatform = new StartPlatform(world, platformStartPosition, "platform");
AddChild(thePlatform, Constants.DepthPlatform);
//Set up ninjas
ninjaBeingThrown = 1; //always starts at 1 (first ninja, then second ninja, and so on)
ninjasToTossThisLevel = GameData.SharedData.NumberOfNinjasToTossThisLevel; //total number of ninjas to toss for this level
ninja1 = new Ninja(world, ninjaStartPosition1, @"ninja");
AddChild(ninja1, Constants.DepthNinjas);
currentBodyNode = ninja1;
currentBodyNode.SpriteInSlingState();
if (ninjasToTossThisLevel >= 2)
{
ninja2 = new Ninja(world, ninjaStartPosition2, @"ninjaRed");
AddChild(ninja2, Constants.DepthNinjas);
ninja2.SpriteInStandingState();
}
if (ninjasToTossThisLevel >= 3)
{
ninja3 = new Ninja(world, ninjaStartPosition3, @"ninjaBlue");
AddChild(ninja3, Constants.DepthNinjas);
ninja3.SpriteInStandingState();
}
if (ninjasToTossThisLevel >= 4)
{
ninja4 = new Ninja(world, ninjaStartPosition4, @"ninjaBrown");
AddChild(ninja4, Constants.DepthNinjas);
ninja4.SpriteInStandingState();
}
if (ninjasToTossThisLevel >= 5)
{
ninja5 = new Ninja(world, ninjaStartPosition5, @"ninjaGreen");
AddChild(ninja5, Constants.DepthNinjas);
ninja5.SpriteInStandingState();
}
//Build the Stack.
stack = new TheStack(world);
AddChild(stack, Constants.DepthStack);
//give the stack a moment to drop, then switches every pieces to static (locks it into position, until the first slingshot)...
ScheduleOnce(SwitchAllStackObjectsToStatic, 1.0f);
currentScoreLabel = new CCLabelTtf(String.Format("{0}: Needed", pointsToPassLevel), "MarkerFelt", fontSizeForScore);
AddChild(currentScoreLabel, Constants.DepthScore);
currentScoreLabel.Color = new CCColor3B(255, 255, 255);
currentScoreLabel.Position = currentScoreLabelStartPosition;
currentScoreLabel.AnchorPoint = new CCPoint(1, .5f);
// HighScoreForLevel
highScoreLabel = new CCLabelTtf(String.Format("High Score: {0}", GameData.SharedData.HighScoreForLevel), "MarkerFelt", fontSizeForScore);
AddChild(highScoreLabel, Constants.DepthScore);
highScoreLabel.Color = new CCColor3B(255, 255, 255);
highScoreLabel.Position = currentScoreLabel.Position - new CCPoint(0, highScoreLabel.ContentSize.Height);// highScoreLabelStartPosition;
highScoreLabel.AnchorPoint = new CCPoint(1, .5f);
highScoreLabelStartPosition = highScoreLabel.Position;
var levelString = string.Format("Level: {0}", currentLevel);
ShowBoardMessage(levelString);
CCLog.Log(" ");
CCLog.Log(" ");
CCLog.Log(" ");
CCLog.Log("/////////////////////////////////////////////////////");
CCLog.Log("/////////////////////////////////////////////////////");
CCLog.Log(" ");
CCLog.Log(" ");
CCLog.Log(" ");
CCLog.Log("The art and animation in this template is copyright CartoonSmart LLC");
CCLog.Log("You must make significant changes to the art before submitting your game to the App Store");
CCLog.Log("Please create your own characters, backgrounds, etc and spend the time to make the game look totally unique");
CCLog.Log(" ");
CCLog.Log(" ");
CCLog.Log(" ");
CCLog.Log("The Video guide for this template is at https://vimeo.com/cartoonsmart/angryninjasguide ");
CCLog.Log(" ");
CCLog.Log(" ");
CCLog.Log(" ");
CCLog.Log("/////////////////////////////////////////////////////");
CCLog.Log("/////////////////////////////////////////////////////");
CCLog.Log(" ");
CCLog.Log(" ");
GameSounds.SharedGameSounds.IntroTag();
if (GameData.SharedData.Level == 1)
{
GameSounds.SharedGameSounds.PlayBackgroundMusic(AmbientFXSounds.Frogs);
}
else
{
GameSounds.SharedGameSounds.PlayBackgroundMusic(AmbientFXSounds.Insects);
}
if (GameData.SharedData.FirstRunEver && openWithMenuInsteadOfGame)
{
CCLog.Log("First run ever");
Schedule(ShowMenuFromSelector, 2f);
GameData.SharedData.FirstRunEver = false;
}
// Always do this last.
this.Schedule(Tick);
}
public Car()
{
m_hz = 4.0f;
m_zeta = 0.7f;
m_speed = 50.0f;
b2Body ground = null;
{
b2BodyDef bd = new b2BodyDef();
ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
fd.density = 0.0f;
fd.friction = 0.6f;
shape.Set(new b2Vec2(-20.0f, 0.0f), new b2Vec2(20.0f, 0.0f));
ground.CreateFixture(fd);
float[] hs = {0.25f, 1.0f, 4.0f, 0.0f, 0.0f, -1.0f, -2.0f, -2.0f, -1.25f, 0.0f};
float x = 20.0f, y1 = 0.0f, dx = 5.0f;
for (int i = 0; i < 10; ++i)
{
float y2 = hs[i];
shape.Set(new b2Vec2(x, y1), new b2Vec2(x + dx, y2));
ground.CreateFixture(fd);
y1 = y2;
x += dx;
}
for (int i = 0; i < 10; ++i)
{
float y2 = hs[i];
shape.Set(new b2Vec2(x, y1), new b2Vec2(x + dx, y2));
ground.CreateFixture(fd);
y1 = y2;
x += dx;
}
shape.Set(new b2Vec2(x, 0.0f), new b2Vec2(x + 40.0f, 0.0f));
ground.CreateFixture(fd);
x += 80.0f;
shape.Set(new b2Vec2(x, 0.0f), new b2Vec2(x + 40.0f, 0.0f));
ground.CreateFixture(fd);
x += 40.0f;
shape.Set(new b2Vec2(x, 0.0f), new b2Vec2(x + 10.0f, 5.0f));
ground.CreateFixture(fd);
x += 20.0f;
shape.Set(new b2Vec2(x, 0.0f), new b2Vec2(x + 40.0f, 0.0f));
ground.CreateFixture(fd);
x += 40.0f;
shape.Set(new b2Vec2(x, 0.0f), new b2Vec2(x, 20.0f));
ground.CreateFixture(fd);
}
// Teeter
{
b2BodyDef bd = new b2BodyDef();
bd.position.Set(140.0f, 1.0f);
bd.type = b2BodyType.b2_dynamicBody;
b2Body body = m_world.CreateBody(bd);
b2PolygonShape box = new b2PolygonShape();
box.SetAsBox(10.0f, 0.25f);
body.CreateFixture(box, 1.0f);
b2RevoluteJointDef jd = new b2RevoluteJointDef();
jd.Initialize(ground, body, body.Position);
jd.lowerAngle = -8.0f * b2Settings.b2_pi / 180.0f;
jd.upperAngle = 8.0f * b2Settings.b2_pi / 180.0f;
jd.enableLimit = true;
m_world.CreateJoint(jd);
body.ApplyAngularImpulse(100.0f);
}
// Bridge
{
int N = 20;
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(1.0f, 0.125f);
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
fd.density = 1.0f;
fd.friction = 0.6f;
b2RevoluteJointDef jd = new b2RevoluteJointDef();
b2Body prevBody = ground;
for (int i = 0; i < N; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(161.0f + 2.0f * i, -0.125f);
b2Body body = m_world.CreateBody(bd);
body.CreateFixture(fd);
b2Vec2 anchor = new b2Vec2(160.0f + 2.0f * i, -0.125f);
jd.Initialize(prevBody, body, anchor);
m_world.CreateJoint(jd);
prevBody = body;
}
b2Vec2 anchor1 = new b2Vec2(160.0f + 2.0f * N, -0.125f);
jd.Initialize(prevBody, ground, anchor1);
m_world.CreateJoint(jd);
}
// Boxes
{
b2PolygonShape box = new b2PolygonShape();
box.SetAsBox(0.5f, 0.5f);
b2Body body = null;
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(230.0f, 0.5f);
body = m_world.CreateBody(bd);
body.CreateFixture(box, 0.5f);
bd.position.Set(230.0f, 1.5f);
body = m_world.CreateBody(bd);
body.CreateFixture(box, 0.5f);
bd.position.Set(230.0f, 2.5f);
body = m_world.CreateBody(bd);
body.CreateFixture(box, 0.5f);
bd.position.Set(230.0f, 3.5f);
body = m_world.CreateBody(bd);
body.CreateFixture(box, 0.5f);
bd.position.Set(230.0f, 4.5f);
body = m_world.CreateBody(bd);
body.CreateFixture(box, 0.5f);
}
// Car
{
b2PolygonShape chassis = new b2PolygonShape();
b2Vec2[] vertices = new b2Vec2[8];
vertices[0].Set(-1.5f, -0.5f);
vertices[1].Set(1.5f, -0.5f);
vertices[2].Set(1.5f, 0.0f);
vertices[3].Set(0.0f, 0.9f);
vertices[4].Set(-1.15f, 0.9f);
vertices[5].Set(-1.5f, 0.2f);
chassis.Set(vertices, 6);
b2CircleShape circle = new b2CircleShape();
circle.Radius = 0.4f;
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(0.0f, 1.0f);
m_car = m_world.CreateBody(bd);
m_car.CreateFixture(chassis, 1.0f);
b2FixtureDef fd = new b2FixtureDef();
fd.shape = circle;
fd.density = 1.0f;
fd.friction = 0.9f;
bd.position.Set(-1.0f, 0.35f);
m_wheel1 = m_world.CreateBody(bd);
m_wheel1.CreateFixture(fd);
bd.position.Set(1.0f, 0.4f);
m_wheel2 = m_world.CreateBody(bd);
m_wheel2.CreateFixture(fd);
b2WheelJointDef jd = new b2WheelJointDef();
b2Vec2 axis = new b2Vec2(0.0f, 1.0f);
jd.Initialize(m_car, m_wheel1, m_wheel1.Position, axis);
jd.motorSpeed = 0.0f;
jd.maxMotorTorque = 20.0f;
jd.enableMotor = true;
jd.frequencyHz = m_hz;
jd.dampingRatio = m_zeta;
m_spring1 = (b2WheelJoint) m_world.CreateJoint(jd);
jd.Initialize(m_car, m_wheel2, m_wheel2.Position, axis);
jd.motorSpeed = 0.0f;
jd.maxMotorTorque = 10.0f;
jd.enableMotor = false;
jd.frequencyHz = m_hz;
jd.dampingRatio = m_zeta;
m_spring2 = (b2WheelJoint) m_world.CreateJoint(jd);
}
}
public Revolute()
{
b2Body ground;
{
b2BodyDef bd = new b2BodyDef();
ground = m_world.CreateBody(bd);
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
//fd.filter.categoryBits = 2;
ground.CreateFixture(fd);
}
{
b2CircleShape shape = new b2CircleShape();
shape.Radius = 0.5f;
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
b2RevoluteJointDef rjd = new b2RevoluteJointDef();
bd.position.Set(-10.0f, 20.0f);
b2Body body = m_world.CreateBody(bd);
body.CreateFixture(shape, 5.0f);
float w = 100.0f;
body.AngularVelocity = w;
body.LinearVelocity = new b2Vec2(-8.0f * w, 0.0f);
rjd.Initialize(ground, body, new b2Vec2(-10.0f, 12.0f));
rjd.motorSpeed = 1.0f * b2Settings.b2_pi;
rjd.maxMotorTorque = 10000.0f;
rjd.enableMotor = false;
rjd.lowerAngle = -0.25f * b2Settings.b2_pi;
rjd.upperAngle = 0.5f * b2Settings.b2_pi;
rjd.enableLimit = true;
rjd.CollideConnected = true;
m_joint = (b2RevoluteJoint) m_world.CreateJoint(rjd);
}
{
b2CircleShape circle_shape = new b2CircleShape();
circle_shape.Radius = 3.0f;
b2BodyDef circle_bd = new b2BodyDef();
circle_bd.type = b2BodyType.b2_dynamicBody;
circle_bd.position.Set(5.0f, 30.0f);
b2FixtureDef fd = new b2FixtureDef();
fd.density = 5.0f;
fd.filter.maskBits = 1;
fd.shape = circle_shape;
m_ball = m_world.CreateBody(circle_bd);
m_ball.CreateFixture(fd);
b2PolygonShape polygon_shape = new b2PolygonShape();
polygon_shape.SetAsBox(10.0f, 0.2f, new b2Vec2(-10.0f, 0.0f), 0.0f);
b2BodyDef polygon_bd = new b2BodyDef();
polygon_bd.position.Set(20.0f, 10.0f);
polygon_bd.type = b2BodyType.b2_dynamicBody;
polygon_bd.bullet = true;
b2Body polygon_body = m_world.CreateBody(polygon_bd);
polygon_body.CreateFixture(polygon_shape, 2.0f);
b2RevoluteJointDef rjd = new b2RevoluteJointDef();
rjd.Initialize(ground, polygon_body, new b2Vec2(20.0f, 10.0f));
rjd.lowerAngle = -0.25f * b2Settings.b2_pi;
rjd.upperAngle = 0.0f * b2Settings.b2_pi;
rjd.enableLimit = true;
m_world.CreateJoint(rjd);
}
// Tests mass computation of a small object far from the origin
{
b2BodyDef bodyDef = new b2BodyDef();
bodyDef.type = b2BodyType.b2_dynamicBody;
b2Body body = m_world.CreateBody(bodyDef);
b2PolygonShape polyShape = new b2PolygonShape();
b2Vec2[] verts = new b2Vec2[3];
verts[0].Set(17.63f, 36.31f);
verts[1].Set(17.52f, 36.69f);
verts[2].Set(17.19f, 36.36f);
polyShape.Set(verts, 3);
b2FixtureDef polyFixtureDef = new b2FixtureDef();
polyFixtureDef.shape = polyShape;
polyFixtureDef.density = 1;
body.CreateFixture(polyFixtureDef); //assertion hits inside here
}
}
public override b2Shape Clone()
{
b2EdgeShape clone = new b2EdgeShape(this);
return(clone);
}
public Dominos()
{
b2Body b1;
{
b2EdgeShape shape = new b2EdgeShape();
shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
b2BodyDef bd = new b2BodyDef();
b1 = m_world.CreateBody(bd);
b1.CreateFixture(shape, 0.0f);
}
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(6.0f, 0.25f);
b2BodyDef bd = new b2BodyDef();
bd.position.Set(-1.5f, 10.0f);
b2Body ground = m_world.CreateBody(bd);
ground.CreateFixture(shape, 0.0f);
}
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.1f, 1.0f);
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
fd.density = 20.0f;
fd.friction = 0.1f;
for (int i = 0; i < 10; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-6.0f + 1.0f * i, 11.25f);
b2Body body = m_world.CreateBody(bd);
body.CreateFixture(fd);
}
}
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(7.0f, 0.25f, b2Vec2.Zero, 0.3f);
b2BodyDef bd = new b2BodyDef();
bd.position.Set(1.0f, 6.0f);
b2Body ground = m_world.CreateBody(bd);
ground.CreateFixture(shape, 0.0f);
}
b2Body b2;
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.25f, 1.5f);
b2BodyDef bd = new b2BodyDef();
bd.position.Set(-7.0f, 4.0f);
b2 = m_world.CreateBody(bd);
b2.CreateFixture(shape, 0.0f);
}
b2Body b3;
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(6.0f, 0.125f);
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-0.9f, 1.0f);
bd.angle = -0.15f;
b3 = m_world.CreateBody(bd);
b3.CreateFixture(shape, 10.0f);
}
b2RevoluteJointDef jd = new b2RevoluteJointDef();
b2Vec2 anchor = new b2Vec2();
anchor.Set(-2.0f, 1.0f);
jd.Initialize(b1, b3, anchor);
jd.CollideConnected = true;
m_world.CreateJoint(jd);
b2Body b4;
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.25f, 0.25f);
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(-10.0f, 15.0f);
b4 = m_world.CreateBody(bd);
b4.CreateFixture(shape, 10.0f);
}
anchor.Set(-7.0f, 15.0f);
jd.Initialize(b2, b4, anchor);
m_world.CreateJoint(jd);
b2Body b5;
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(6.5f, 3.0f);
b5 = m_world.CreateBody(bd);
b2PolygonShape shape = new b2PolygonShape();
b2FixtureDef fd = new b2FixtureDef();
fd.shape = shape;
fd.density = 10.0f;
fd.friction = 0.1f;
shape.SetAsBox(1.0f, 0.1f, new b2Vec2(0.0f, -0.9f), 0.0f);
b5.CreateFixture(fd);
shape.SetAsBox(0.1f, 1.0f, new b2Vec2(-0.9f, 0.0f), 0.0f);
b5.CreateFixture(fd);
shape.SetAsBox(0.1f, 1.0f, new b2Vec2(0.9f, 0.0f), 0.0f);
b5.CreateFixture(fd);
}
anchor.Set(6.0f, 2.0f);
jd.Initialize(b1, b5, anchor);
m_world.CreateJoint(jd);
b2Body b6;
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(1.0f, 0.1f);
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(6.5f, 4.1f);
b6 = m_world.CreateBody(bd);
b6.CreateFixture(shape, 30.0f);
}
anchor.Set(7.5f, 4.0f);
jd.Initialize(b5, b6, anchor);
m_world.CreateJoint(jd);
b2Body b7;
{
b2PolygonShape shape = new b2PolygonShape();
shape.SetAsBox(0.1f, 1.0f);
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(7.4f, 1.0f);
b7 = m_world.CreateBody(bd);
b7.CreateFixture(shape, 10.0f);
}
b2DistanceJointDef djd = new b2DistanceJointDef();
djd.BodyA = b3;
djd.BodyB = b7;
djd.localAnchorA.Set(6.0f, 0.0f);
djd.localAnchorB.Set(0.0f, -1.0f);
b2Vec2 d = djd.BodyB.GetWorldPoint(djd.localAnchorB) - djd.BodyA.GetWorldPoint(djd.localAnchorA);
djd.length = d.Length;
m_world.CreateJoint(djd);
{
float radius = 0.2f;
b2CircleShape shape = new b2CircleShape();
shape.Radius = radius;
for (int i = 0; i < 4; ++i)
{
b2BodyDef bd = new b2BodyDef();
bd.type = b2BodyType.b2_dynamicBody;
bd.position.Set(5.9f + 2.0f * radius * i, 2.4f);
b2Body body = m_world.CreateBody(bd);
body.CreateFixture(shape, 10.0f);
}
}
}