cpBody *cpSpaceSerializer::createBody(TiXmlElement *elm) { TiXmlElement *bodyElm;; cpBody *body; CPSS_ID b_id = createValue<CPSS_ID>("body_id", elm); BodyMap::iterator itr = _bodyMap.find(b_id); //If it doesn't exist, try to create it if (itr == _bodyMap.end()) { bodyElm = elm->FirstChildElement("body"); if (bodyElm) { cpFloat mass = createValue<cpFloat>("mass", bodyElm); cpFloat inertia = createValue<cpFloat>("inertia", bodyElm); if (mass == INFINITY) body = cpBodyNewStatic(); else body = cpBodyNew(mass, inertia); body->p = createPoint("p", bodyElm); body->v = createPoint("v", bodyElm); body->f = createPoint("f", bodyElm); body->w = createValue<cpFloat>("w", bodyElm); body->t = createValue<cpFloat>("t", bodyElm); cpBodySetAngle(body, createValue<cpFloat>("a", bodyElm)); _bodyMap[b_id] = body; if (delegate && b_id != 0) { if (!delegate->reading(body, b_id)) { cpBodyFree(body); body = NULL; } } } else body = cpBodyNewStatic(); //Fail case, should throw or something } else body = itr->second; //Else grab it return body; }
World::World(cpVect size) { space=cpSpaceNew(); static_body=cpBodyNewStatic(); printf("new space\n"); fflush(stdout); cpVect s2=cpvmult(size,0.5); cpVect c1=s2; cpVect c2=cpv(s2.x,-s2.y); cpVect c3=cpv(-s2.x,-s2.y); cpVect c4=cpv(-s2.x,s2.y); printf("foo space\n"); fflush(stdout); cpBodyInitStatic(space->staticBody); addStaticLine(c1,c2); addStaticLine(c2,c3); addStaticLine(c3,c4); addStaticLine(c4,c1); printf("space done\n"); fflush(stdout); }
MachineSystem::MachineSystem(int width, int height, int hPegs, int vPegs, cpVect position) : parts(hPegs*vPegs), attachments((hPegs*vPegs), std::vector<Attachment *>(hPegs*vPegs, NULL)), space(cpSpaceNew()), nMachines(0), nAttachments(0) { cpSpaceSetIterations(space, 20); gridSpacing = cpv((float)width/(hPegs + 1), (float)height/(vPegs + 1)); size = cpv(hPegs, vPegs); body = cpBodyNewStatic(); cpBodySetPos(body, position); cpShape *wallShape = cpSegmentShapeNew(body, cpv(-width/2, height/2), cpv(width/2, height/2), .5); cpShapeSetLayers(wallShape, WALL_LAYER); cpSpaceAddStaticShape(space, wallShape); wallShape = cpSegmentShapeNew(body, cpv(-width/2, -height/2), cpv(+width/2, -height/2), 0.5); cpShapeSetLayers(wallShape, WALL_LAYER); cpSpaceAddStaticShape(space, wallShape); wallShape = cpSegmentShapeNew(body, cpv(-width/2, +height/2), cpv(-width/2, -height/2), 0.5); cpShapeSetLayers(wallShape, WALL_LAYER); cpSpaceAddStaticShape(space, wallShape); wallShape = cpSegmentShapeNew(body, cpv(+width/2, +height/2), cpv(+width/2, -height/2), 0.5); cpShapeSetLayers(wallShape, WALL_LAYER); cpSpaceAddStaticShape(space, wallShape); inputMachinePosition = cpv(-1,-1); outputMachinePosition = cpv(-1,-1); }
static palette_object_t *createPaletteObject(cpVect p, char *file, int dam, float m) { image_t *img; palette_object_t *obj; int numVerts = 4; cpVect verts[] = { {-16, -16}, {-16, 16}, { 16, 16}, { 16, -16} }; obj = (palette_object_t *)malloc(sizeof(palette_object_t)); obj->maxDamage = dam; obj->m = m; if (file) { img = atlFindImageFile(file, false, GL_CLAMP); strncpy(obj->texfile, img->name, PATH_MAX); obj->texnum = img->texnum; } else { obj->texnum = -1; } obj->body = cpBodyNewStatic(); obj->body->p = p; obj->shape = cpPolyShapeNew(obj->body, numVerts, verts, cpvzero); obj->shape->data = obj; obj->shape->collision_type = PALETTE_TYPE; cpSpaceAddShape(g_Space, obj->shape); return obj; }
void LevelGrid::InitializeLevelPhysics(void) { // Fetch the physics space cpSpace *space = this->m_Engine->GetWorld()->GetSpace(); // Add the physics body this->m_Body = cpBodyNewStatic(); // Add the physics shapes for (int i = 0 ; i < this->m_NumY - 1 ; ++i) { hgeVector *vec = this->m_LeftLevelVertices[i]; hgeVector *nvec = this->m_LeftLevelVertices[i + 1]; cpShape *shape = cpSegmentShapeNew(this->m_Body, cpv(vec->x, vec->y), cpv(nvec->x, nvec->y), 0.0f); shape->e = 1.0; shape->u = 1.0; shape->collision_type = COLLISION_TYPE_LEVEL; cpSpaceAddStaticShape(space, shape); cpBodyActivateStatic(this->m_Body, shape); this->m_Shapes.push_back(shape); } for (int i = 0 ; i < this->m_NumY - 1 ; ++i) { hgeVector *vec = this->m_RightLevelVertices[i]; hgeVector *nvec = this->m_RightLevelVertices[i + 1]; cpShape *shape = cpSegmentShapeNew(this->m_Body, cpv(vec->x, vec->y), cpv(nvec->x, nvec->y), 0.0f); shape->e = 1.0; shape->u = 1.0; shape->collision_type = COLLISION_TYPE_LEVEL; cpSpaceAddStaticShape(space, shape); cpBodyActivateStatic(this->m_Body, shape); this->m_Shapes.push_back(shape); } // Create the activator physics shapes for (int i = 0 ; i < this->m_NumActivators ; ++i) { Activator *activator = this->m_Activators[i]; // Create the cpVects cpVect *verts = (cpVect*) malloc(sizeof(cpVect) * 4); verts[3].x = activator->Vertices[0].x; verts[3].y = activator->Vertices[0].y; verts[2].x = activator->Vertices[1].x; verts[2].y = activator->Vertices[1].y; verts[1].x = activator->Vertices[2].x; verts[1].y = activator->Vertices[2].y; verts[0].x = activator->Vertices[3].x; verts[0].y = activator->Vertices[3].y; // Create and add the poly shape cpShape *shape = cpPolyShapeNew(this->m_Body, 4, verts, cpvzero); shape->e = 1.0; shape->u = 1.0; shape->sensor = true; shape->collision_type = COLLISION_TYPE_ACTIVATOR; shape->data = activator; cpSpaceAddStaticShape(space, shape); cpBodyActivateStatic(this->m_Body, shape); this->m_Shapes.push_back(shape); free(verts); } }
int lc_NewStaticBody(lua_State *vm){ //-> body lc_object *object_body = lua_newuserdata(vm, sizeof(lc_object)); object_body->type = Body; object_body->object = cpBodyNewStatic(); lua_getfield(vm, LUA_REGISTRYINDEX, "chipmunk.bodymeta"); lua_setmetatable(vm, -2); return 1; }
static cpBody *MakeBody(const float x, const float y, const float w) { cpBody *body = cpSpaceAddBody(space.Space, cpBodyNewStatic()); cpBodySetPosition(body, cpv(x + w / 2, y - GAP_HEIGHT / 2)); cpShape *shape = cpSpaceAddShape( space.Space, cpBoxShapeNew(body, w, GAP_HEIGHT, 0.0)); cpShapeSetElasticity(shape, BLOCK_ELASTICITY); cpShapeSetFriction(shape, 1.0f); return body; }
PhysicsShapeInfo::PhysicsShapeInfo(PhysicsShape* shape) : _shape(shape) , _group(CP_NO_GROUP) { if (_sharedBody == nullptr) { _sharedBody = cpBodyNewStatic(); } _body = _sharedBody; }
PhysicsShapeInfo::PhysicsShapeInfo(PhysicsShape* shape) : shape(shape) , group(CP_NO_GROUP) { if (shareBody == nullptr) { shareBody = cpBodyNewStatic(); } body = shareBody; }
Coin::Coin(int p) : price(p) { #if STATIC_OBJECT == 1 coinBody = cpBodyNewStatic(); #else coinBody = cpBodyNew(INFINITY, INFINITY); #endif coinShape = cpCircleShapeNew(coinBody, COIN_R, cpv(0,0)); //CCLog("coin shape %x", coinShape); coinShape->collision_type = GameScreen::COIN_COLLISION; //coinBody-> coinBody->v = cpv(0, absV); }
cpBody* RigidBody2D::Create(float mass, float moment) { cpBody* handle; if (IsKinematic()) { if (IsStatic()) handle = cpBodyNewStatic(); else handle = cpBodyNewKinematic(); } else handle = cpBodyNew(mass, moment); cpBodySetUserData(handle, this); return handle; }
int l_physics_newCircleBody(lua_State* state) { l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a space"); l_physics_PhysicsData* physics = (l_physics_PhysicsData*)lua_touserdata(state, 1); const char* type = luaL_optstring(state, 2, "dynamic"); float outer_radius = luaL_optnumber(state, 3, 1.0f); cpVect offset = cpvzero; offset.x = luaL_optnumber(state, 4, 0.0f); offset.y = luaL_optnumber(state, 5, 0.0f); float mass = luaL_optnumber(state, 6, 1.0f); float moment = luaL_optnumber(state, 7, 0.0f); float inner_radius = luaL_optnumber(state, 8, 0.0f); moduleData.body = (l_physics_Body*)lua_newuserdata(state, sizeof(l_physics_Body)); moduleData.body->physics = malloc(sizeof(physics_PhysicsData)); moduleData.body->physics = physics->physics; cpFloat _moment = moment; if (_moment == 0) _moment = cpMomentForCircle(mass, inner_radius, outer_radius, offset); if (strcmp(type, "dynamic") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewDynamic()); else if (strcmp(type, "kinematic") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewKinematic()); else if (strcmp(type, "static") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewStatic()); else { moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNew(mass, _moment)); /* const char* err = util_concatenate("Undefined type: ", type); l_tools_trowError(state, err); return -1; */ } lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.bodyMT); lua_setmetatable(state, -2); return 1; }
int l_physics_newBoxBody(lua_State* state) { l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a space"); l_physics_PhysicsData* physics = (l_physics_PhysicsData*)lua_touserdata(state, 1); const char* type = l_tools_toStringOrErrorPlusMsg(state, 2, "You must provide a type, eg: dynamic,static,kinematic"); float width = l_tools_toNumberOrErrorPlusMsg(state, 3, "You must provide a width"); float height = luaL_optnumber(state, 4, width); float mass = luaL_optnumber(state, 5, 1.0f); float moment = luaL_optnumber(state, 6, 0.0f); moduleData.body = (l_physics_Body*)lua_newuserdata(state, sizeof(l_physics_Body)); moduleData.body->physics = malloc(sizeof(physics_PhysicsData)); moduleData.body->physics = physics->physics; cpFloat _moment = moment; // If we don't provide a default moment then we let chipmunk calculate one if (_moment == 0) _moment = cpMomentForBox(mass, width, height); if (strcmp(type, "dynamic") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewDynamic()); else if (strcmp(type, "static") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewStatic()); else if (strcmp(type, "kinematic") == 0) moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNewKinematic()); else { moduleData.body->body = cpSpaceAddBody(physics->physics->space, cpBodyNew(mass, _moment)); /* const char* err = util_concatenate("Undefined type: ", type); l_tools_trowError(state, err); return -1; */ } lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.bodyMT); lua_setmetatable(state, -2); return 1; }
// NOTE - don't use a GEAR attachment to attach to the wall - the peg does not rotate, so the body will not rotate void MachineSystem::addPart(MachinePart *newPart, Attachment *attachment, cpVect gridPosition) { int machineNumber = machinePositionToNumber(gridPosition); MachinePart *alreadyAttached = parts[machineNumber]; if (!alreadyAttached) { cpVect pegPosition = gridPositionToWorld(gridPosition); cpBody *pegBody = cpBodyNewStatic(); cpBodySetPos(pegBody, pegPosition); cpShape *pegShape = cpCircleShapeNew(pegBody, 5.0, cpv(0,0)); cpShapeSetLayers(pegShape, PEG_LAYER); cpSpaceAddStaticShape(space, pegShape); parts[machineNumber] = newPart; nMachines++; newPart->setOriginalPosition(pegPosition); newPart->attachToBody(attachment, pegBody); attachments[machineNumber][machineNumber] = attachment; } }
PhysicsShape::PhysicsShape() : _body(nullptr) , _type(Type::UNKNOWN) , _area(0.0f) , _mass(0.0f) , _moment(0.0f) , _sensor(false) , _scaleX(1.0f) , _scaleY(1.0f) , _newScaleX(1.0f) , _newScaleY(1.0f) , _tag(0) , _categoryBitmask(UINT_MAX) , _collisionBitmask(UINT_MAX) , _contactTestBitmask(0) , _group(0) { if (s_sharedBody == nullptr) { s_sharedBody = cpBodyNewStatic(); } }
MachineSystem::MachineSystem(MachineSystem &original, cpVect position) : space(cpSpaceNew()), size(original.size), gridSpacing(original.gridSpacing), inputMachinePosition(original.inputMachinePosition), outputMachinePosition(original.outputMachinePosition), nMachines(0), nAttachments(0), destroyAttachments(original.destroyAttachments) { cpFloat width = (original.size.x +1)*original.gridSpacing.x; cpFloat height = (original.size.y +1)*original.gridSpacing.y; body = cpBodyNewStatic(); cpBodySetPos(body, position); cpShape *wallShape = cpSegmentShapeNew(body, cpv(-width/2, height/2), cpv(width/2, height/2), .5); cpShapeSetLayers(wallShape, WALL_LAYER); cpSpaceAddStaticShape(space, wallShape); wallShape = cpSegmentShapeNew(body, cpv(-width/2, -height/2), cpv(+width/2, -height/2), 0.5); cpShapeSetLayers(wallShape, WALL_LAYER); cpSpaceAddStaticShape(space, wallShape); wallShape = cpSegmentShapeNew(body, cpv(-width/2, +height/2), cpv(-width/2, -height/2), 0.5); cpShapeSetLayers(wallShape, WALL_LAYER); cpSpaceAddStaticShape(space, wallShape); wallShape = cpSegmentShapeNew(body, cpv(+width/2, +height/2), cpv(+width/2, -height/2), 0.5); cpShapeSetLayers(wallShape, WALL_LAYER); cpSpaceAddStaticShape(space, wallShape); // do the copy of the attachment and machines manually, because we need to add and attach machines int nPegs = size.x*size.y; parts.resize(nPegs, NULL); attachments.resize(nPegs); for (int i=0; i<nPegs; i++) attachments[i].resize(nPegs, NULL); for (int x = 0; x < size.x; x++ ) { for (int y = 0; y < size.y; y++) { cpVect gridPos = cpv(x,y); int machineNum = machinePositionToNumber(gridPos); MachinePart *machineToCopy = original.parts[machineNum]; if (machineToCopy) { MachinePart *newPart = new MachinePart(*machineToCopy, space); Attachment *wallAttachment = Attachment::copyAttachment(original.attachments[machineNum][machineNum]); addPart(newPart, wallAttachment, gridPos); } } } for (int i=0; i<nPegs; i++) { for (int j=0; j<i; j++) { Attachment *attachmentToCopy = original.attachments[i][j]; if (attachmentToCopy) { Attachment *attachmentCopy = Attachment::copyAttachment(attachmentToCopy); cpVect machine1Pos = machineNumberToPosition(i); cpVect machine2Pos = machineNumberToPosition(j); attachMachines(machine1Pos, machine2Pos, attachmentCopy); attachmentCopy->innovationNumber = attachmentToCopy->innovationNumber; } } } }
cBody::cBody() : mBody( cpBodyNewStatic() ), mData( NULL ) { SetData(); }
bool Unit::Create( int id, std::string proto ) { UnitId = id; if( !setUnitName( TypeName ) ) return false; if( !Image.init( UnitName, TypeName ) ) return false; if( proto == "" ){ LuaConfig* cfg = new LuaConfig; cfg->getValue( "proto", UnitName, TypeName, proto ); delete cfg; } if( proto == "" ){ Debug::debug( Debug::UNIT, "Unit with blank prototype, creation failed. UID: " + citoa(UnitId) + ".\n" ); return false; } { ProtoManager* pm = new ProtoManager; Actions.setProto( pm->GetProtoByName( proto ) ); Actions.setAction( "init" ); delete pm; if( !Actions.loaded ){ Debug::debug( Debug::UNIT, "Unit with invalid prototype '" + proto + "'. Creation failed. UID: " + citoa(UnitId) + ".\n" ); return false; } } // Create physics if( Actions.proto->statical ){ physBody = cpBodyNewStatic(); }else{ physBody = cpBodyNew( 1.0, 1.0 ); physBody = cpSpaceAddBody( Phys::space, physBody ); } physBody->data = this; if( Actions.proto->physicsType >= 0 && Actions.proto->physicsType < potLast ) phys.type = (enum PhysObectType)Actions.proto->physicsType; else{ Debug::debug( Debug::UNIT, "Bad physics object type: " + citoa( Actions.proto->physicsType ) + ".\n" ); phys.type = potNone; } cpShape* shape = NULL; switch( phys.type ){ case potCircle: shape = cpCircleShapeNew( physBody, phys.radius, cpvzero ); break; case potQuad: shape = cpBoxShapeNew( physBody, phys.sides.x, phys.sides.y ); break; default: break; } if( shape != NULL ){ physShape = cpSpaceAddShape( Phys::space, shape ); physShape->collision_type = UnitType; } //physBody->velocity_func = call_velocity_func; return true; }
static VALUE rb_cpBodyAllocStatic(VALUE klass) { cpBody *body = cpBodyNewStatic(); return Data_Wrap_Struct(c_cpStaticBody, NULL, cpBodyFree, body); }
Body::Body(void) : body(cpBodyNewStatic()), data(0) { body->data = this; }
void ofxChipmunk::StaticBody::setup(cpSpace *space){ Body::setup(space, cpBodyNewStatic()); }