예제 #1
0
void update_brickwall(SPRITESPTR brickwall)
{
    int nflags = 0;

	brickwall->shape->body->v = cpv(-180, 0);

    add_element_to_render_queue(brickwall->sdata.currentimg->image, brickwall->sdata.x, brickwall->sdata.y, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    brickwall->sdata.x = brickwall->shape->body->p.x-brickwall->sdata.currentimg->width/2;
    brickwall->sdata.y = brickwall->shape->body->p.y-brickwall->sdata.currentimg->height/2;

    if((brickwall->sdata.animflags & MDOWN))
    {
        ALLEGRO_MOUSE_STATE mouse;
        al_get_mouse_state(&mouse);
        float x = brickwall->sdata.x;
        float y = brickwall->sdata.y;
        float width = brickwall->sdata.currentimg->width;
        float height = brickwall->sdata.currentimg->height;

        if((mouse.x >= x && mouse.x <= x+width) && (mouse.y >= y && mouse.y <= y+height))
        {
			cpSpaceAddPostStepCallback(get_global_cpSpace(), &remove_enemy, brickwall, NULL);
            score += 2;
        }
        remove_anim_flags_on_sprite(brickwall, MDOWN);
    }

    if(brickwall->sdata.x+brickwall->sdata.currentimg->width <= 0)
		cpSpaceAddPostStepCallback(get_global_cpSpace(), &remove_enemy, brickwall, NULL);
}
예제 #2
0
// collision arbiter function 
static int core_begin_collision ( cpArbiter *arb, cpSpace *space, void *unused ) {
    CP_ARBITER_GET_SHAPES ( arb, a, b );
    
    ((GameInfo *)space->data)->destroyed_planet = ((BodyInfo *)(b->body->data))->index;
    cpSpaceAddPostStepCallback (space, (cpPostStepFunc)postStepRemoveBody, b->body, NULL);
    cpSpaceAddPostStepCallback ( space, (cpPostStepFunc)post_step_game_over, NULL, NULL );
    
    return 0;
}
예제 #3
0
// adds a freestyle shape given a pointer to a an array of vertices and the number of vertices
//returns a cpbody due to the many shapes associated with one body
cpBody *core_add_freestyle_shape ( cpSpace * space, cpVect* verts , const int num_verts, Color *color, const double friction, const double elasticity, const double density, const int index ) {
    
    if ( num_verts <= 1 ) return NULL;
    
    // first determine center of mass of object
    cpVect center; 
    core_freestyle_center ( verts, num_verts, &center );
    
    // calculate mass and moment 
    cpFloat mass = core_freestyle_mass ( verts, num_verts, density );
    // dummy moment calculation
    cpFloat moment = core_freestyle_moment ( verts, num_verts, center, density );
    
    cpBody *body = cpBodyNew ( mass, moment );
    cpSpaceAddPostStepCallback ( space, (cpPostStepFunc)postStepAddBody, body, NULL );
    cpBodySetPos ( body, center );
    
    // set index of body
    // add body info to body
    BodyInfo * bi = body_info_new(num_verts);
    bi->index = index;
    bi->type = FREESTYLE_TYPE;
    bi->num_verts = num_verts;
    
    for ( int i = 0; i < num_verts; i++ ) {
        (bi->verts[i]).x = verts[i].x;
        (bi->verts[i]).y = verts[i].y;
    }
    
    bi->color->r = color->r;
    bi->color->g = color->g;
    bi->color->b = color->b;
    bi->friction = friction;
    bi->density = density;
    bi->elasticity = elasticity;
    
    body->data = bi;
    
    // add line segment collision shapes to body
    for ( int i = 0; i < num_verts - 1; i++ ) {
        
        cpVect offset_a = cpvmult ( cpvsub ( verts[i], center), 1.0 );
        cpVect offset_b = cpvmult ( cpvsub ( verts[i+1], center), 1.0 );
        
        cpShape * segment = cpSegmentShapeNew ( body, offset_a, offset_b, 0.1 );
        cpSpaceAddPostStepCallback ( space, (cpPostStepFunc) postStepAddShape, segment, NULL);
        segment->u = friction;
        
        DrawShapeInfo *info = draw_shape_info_new ();
        info->color->r = color->r;
        info->color->g = color->g;
        info->color->b = color->b;
        
        segment->data = ( cpDataPointer ) info;
    }
    return body;
}
예제 #4
0
// adds nonstatic box shape to space
// currently does not roate box
static cpShape *core_add_box_shape ( cpSpace *space, Box *box, const int index ) {
    
    // calculate mass and moment of a box
    cpFloat mass = box->density * box->width * box->height;
    cpFloat moment = cpMomentForBox ( mass, box->width, box->height );
    
    // add body with mass and moment of a square to space
    cpBody *body = cpBodyNew ( mass, moment );
    cpSpaceAddPostStepCallback ( space, (cpPostStepFunc) postStepAddBody, body, NULL );
    
    cpBodySetPos ( body, cpv ( box->x, box->y ) );
    
    // set index of body
    BodyInfo * bi = body_info_new(0);
    bi->index = index;
    bi->type = BOX_TYPE;
    bi->p1x = box->x - (box->width) / 2.0;
    bi->p1y = box->y + (box->height) / 2.0;
    bi->p2x = box->x + (box->width) / 2.0;;
    bi->p2y = box->y - (box->height) / 2.0;
    bi->color->r = box->color->r;
    bi->color->g = box->color->g;
    bi->color->b = box->color->b;
    bi->friction = box->friction;
    bi->density = box->density;
    bi->elasticity = box->elasticity;
    
    body->data = bi;
    
    double hw = ( box->width ) / 2.0;
    double hh = ( box->height ) / 2.0;
    cpVect cpv1 = cpv ( -hw,-hh );
    cpVect cpv2 = cpv ( -hw, hh );
    cpVect cpv3 = cpv ( hw, hh );
    cpVect cpv4 = cpv ( hw, -hh );
    
    cpVect verts [4]= { cpv1, cpv2, cpv3, cpv4 };
    
    // add box collision shape to body
    cpShape *boxShape = cpPolyShapeNew ( body, 4, verts, cpv ( 0, 0 ) );
    cpSpaceAddPostStepCallback ( space, (cpPostStepFunc) postStepAddShape, boxShape, NULL );
    
    cpShapeSetFriction ( boxShape, box->friction );
    cpShapeSetElasticity ( boxShape, box->elasticity );
    cpBodySetAngle ( body, box->angle);
    
    DrawShapeInfo *info = add_box_draw_shape_info ( box );
    boxShape->data= ( cpDataPointer ) info;
    return boxShape;
}
예제 #5
0
void update_clamp(SPRITESPTR clamp)
{
    int nflags = 0;
    SIMAGEPTR arm = search_image_list_for_element(&(clamp->ifirstptr), "ARM");

    if(clamp->sdata.x <= 200)
    {
        if(clamp->sdata.y+clamp->sdata.currentimg->height >= 470)
			clamp->shape->body->v = cpv(-180, 0);
        else
			clamp->shape->body->v = cpv(-180, 500);
    }
    else
		clamp->shape->body->v = cpv(-180, 0);

    if((clamp->sdata.animflags & MATTACK))
        clamp->sdata.currentimg = search_image_list_for_element(&clamp->ifirstptr, "CLAMP_CLOSE");

    add_element_to_render_queue(clamp->sdata.currentimg->image, clamp->sdata.x, clamp->sdata.y, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    add_element_to_render_queue(arm->image, clamp->sdata.x, clamp->sdata.y-arm->height, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    add_element_to_render_queue(arm->image, clamp->sdata.x, clamp->sdata.y-arm->height-arm->height, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    clamp->sdata.x = clamp->shape->body->p.x-clamp->sdata.currentimg->width/2;
    clamp->sdata.y = clamp->shape->body->p.y-clamp->sdata.currentimg->height/2;

    if(clamp->sdata.x+clamp->sdata.currentimg->width <= 0)
		cpSpaceAddPostStepCallback(get_global_cpSpace(), &remove_enemy, clamp, NULL);
}
예제 #6
0
void update_plant(SPRITESPTR plant)
{
    int nflags = 0;
    SIMAGEPTR stem = search_image_list_for_element(&(plant->ifirstptr), "STEM");

    if(plant->sdata.x <= res_width/4)
    {
        if(plant->sdata.y+plant->sdata.currentimg->height <= 440)
        {
			plant->shape->body->v = cpv(-180, 0);
            plant->sdata.currentimg = search_image_list_for_element(&(plant->ifirstptr), "PLANT_1");
        }
        else
			plant->shape->body->v = cpv(-180, -200);
    }
    else
		plant->shape->body->v = cpv(-180, 0);

    add_element_to_render_queue(plant->sdata.currentimg->image, plant->sdata.x, plant->sdata.y, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    add_element_to_render_queue(stem->image, plant->sdata.x, plant->sdata.y+plant->sdata.currentimg->height, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    plant->sdata.x = plant->shape->body->p.x-plant->sdata.currentimg->width/2;
    plant->sdata.y = plant->shape->body->p.y-plant->sdata.currentimg->height/2;

    if(plant->sdata.x+plant->sdata.currentimg->width <= 0)
        cpSpaceAddPostStepCallback(get_global_cpSpace(), &remove_enemy, plant, NULL);
}
예제 #7
0
void update_ameans(SPRITESPTR amean)
{
    int nflags = 0;

	amean->shape->body->v = cpv(-180, 0);

    amean->sdata.anim_counter++;
    if(amean->sdata.anim_counter < 7)
    {
        amean->sdata.currentimg = search_image_list_for_element(&amean->ifirstptr, "AMEAN_1");
    }
    else if(amean->sdata.anim_counter > 7 && amean->sdata.anim_counter < 14)
    {
        amean->sdata.currentimg = search_image_list_for_element(&amean->ifirstptr, "AMEAN_2");
    }
    else if(amean->sdata.anim_counter > 14 && amean->sdata.anim_counter < 21)
    {
        amean->sdata.currentimg = search_image_list_for_element(&amean->ifirstptr, "AMEAN_3");
    }
    else if(amean->sdata.anim_counter > 21 && amean->sdata.anim_counter < 28)
    {
        amean->sdata.currentimg = search_image_list_for_element(&amean->ifirstptr, "AMEAN_2");
    }
    else if(amean->sdata.anim_counter > 28)
        amean->sdata.anim_counter = 0;

    add_element_to_render_queue(amean->sdata.currentimg->image, amean->sdata.x, amean->sdata.y, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    amean->sdata.x = amean->shape->body->p.x-amean->sdata.currentimg->width/2;
    amean->sdata.y = amean->shape->body->p.y-amean->sdata.currentimg->height/2;

    if(amean->sdata.x+amean->sdata.currentimg->width <= 0)
        cpSpaceAddPostStepCallback(get_global_cpSpace(), &remove_enemy, amean, NULL);
}
예제 #8
0
// adds static box shape to space
static void core_add_static_box_shape ( cpSpace * space, Box * box ) {    
    
    // add box collision shape to body
    cpFloat hw = box->width / 2.0;
    cpFloat hh = box->height / 2.0;
    
    double x = box->x;
    double y = box->y;
    
    cpVect verts[] = {
        cpv ( x - hw, y - hh ),
        cpv ( x - hw, y + hh ),
        cpv ( x + hw, y + hh ),
        cpv ( x + hw, y - hh ),
    };
    
    cpShape * box_shape = cpPolyShapeNew ( space->staticBody, 4, verts, cpvzero );
    cpShapeSetFriction ( (cpShape *) box_shape, box->friction );
    cpShapeSetElasticity ( (cpShape *) box_shape, box->elasticity );
    
    cpSpaceAddPostStepCallback ( space, (cpPostStepFunc) postStepAddShape, box_shape, NULL );  
    
    DrawShapeInfo *info = add_box_draw_shape_info ( box );
    box_shape->data= ( cpDataPointer ) info;
    
}
예제 #9
0
//destroy bodies out of bound
static void core_destroy_out_bodies ( cpBody *body, void *data ) {
    
    cpVect pos = cpBodyGetPos ( body );
    
    if ( pos.y < -50 || pos.y > (CORE_MAX_HEIGHT + 50) || pos.x < - 50 || pos.x > 200) {
        
        cpSpaceAddPostStepCallback( cpBodyGetSpace(body), (cpPostStepFunc)postStepRemoveBody, body, NULL );
    }
    else return;
}
예제 #10
0
파일: Sensors.c 프로젝트: 0w/moai-dev
static cpBool
catcherBarBegin(cpArbiter *arb, cpSpace *space, void *unused)
{
	cpShape *a, *b; cpArbiterGetShapes(arb, &a, &b);
	Emitter *emitter = (Emitter *) a->data;
	
	emitter->queue++;
	cpSpaceAddPostStepCallback(space, (cpPostStepFunc)postStepRemove, b, NULL);
	
	return cpFalse;
}
예제 #11
0
int fff::explosive::Begin(cpArbiter *arb, cpSpace *space, void *pengine){
    CP_ARBITER_GET_SHAPES(arb, explosiveshape, kittyshape);
    fff::explosive *explosive = static_cast<fff::explosive *>( cpShapeGetUserData(explosiveshape) );
    fff::kitty *kitty = static_cast<fff::kitty *>( cpShapeGetUserData(kittyshape) );
    kitty->applyImpulse(explosive->impulse);
    explosive->setExploding();
    game.playExplosion(explosive->soundbuffer, explosive->sprite.GetPosition() );
    cpSpaceAddPostStepCallback(space, fff::explosive::postStep, explosiveshape, NULL);
    game.startTheme();
    return 0;
}
예제 #12
0
파일: Sticky.c 프로젝트: Adefy/AdefyiOS
static cpBool
StickyPreSolve(cpArbiter *arb, cpSpace *space, void *data)
{
	// We want to fudge the collisions a bit to allow shapes to overlap more.
	// This simulates their squishy sticky surface, and more importantly
	// keeps them from separating and destroying the joint.
	
	// Track the deepest collision point and use that to determine if a rigid collision should occur.
	cpFloat deepest = INFINITY;
	
	// Grab the contact set and iterate over them.
	cpContactPointSet contacts = cpArbiterGetContactPointSet(arb);
	for(int i=0; i<contacts.count; i++){
		// Increase the distance (negative means overlaping) of the
		// collision to allow them to overlap more.
		// This value is used only for fixing the positions of overlapping shapes.
		cpFloat dist = contacts.points[i].dist + 2.0f*STICK_SENSOR_THICKNESS;
		contacts.points[i].dist = cpfmin(0.0f, dist);
		deepest = cpfmin(deepest, dist);
	}
	
	// Set the new contact point data.
	cpArbiterSetContactPointSet(arb, &contacts);
	
	// If the shapes are overlapping enough, then create a
	// joint that sticks them together at the first contact point.
	if(!cpArbiterGetUserData(arb) && deepest <= 0.0f){
		CP_ARBITER_GET_BODIES(arb, bodyA, bodyB);
		
		// Create a joint at the contact point to hold the body in place.
		cpConstraint *joint = cpPivotJointNew(bodyA, bodyB, contacts.points[0].point);
		
		// Give it a finite force for the stickyness.
		cpConstraintSetMaxForce(joint, 3e3);
		
		// Schedule a post-step() callback to add the joint.
		cpSpaceAddPostStepCallback(space, PostStepAddJoint, joint, NULL);
		
		// Store the joint on the arbiter so we can remove it later.
		cpArbiterSetUserData(arb, joint);
	}
	
	// Position correction and velocity are handled separately so changing
	// the overlap distance alone won't prevent the collision from occuring.
	// Explicitly the collision for this frame if the shapes don't overlap using the new distance.
	return (deepest <= 0.0f);
	
	// Lots more that you could improve upon here as well:
	// * Modify the joint over time to make it plastic.
	// * Modify the joint in the post-step to make it conditionally plastic (like clay).
	// * Track a joint for the deepest contact point instead of the first.
	// * Track a joint for each contact point. (more complicated since you only get one data pointer).
}
예제 #13
0
파일: Slice.cpp 프로젝트: damucz/chipmunk2d
void Slice::SliceQuery(cpShape *shape, cpVect point, cpVect normal, cpFloat alpha, struct SliceContext *context)
{
	cpVect a = context->a;
	cpVect b = context->b;
	
	// Check that the slice was complete by checking that the endpoints aren't in the sliced shape.
	if(cpShapePointQuery(shape, a, NULL) > 0.0f && cpShapePointQuery(shape, b, NULL) > 0.0f){
		// Can't modify the space during a query.
		// Must make a post-step callback to do the actual slicing.
		cpSpaceAddPostStepCallback(context->space, (cpPostStepFunc)SliceShapePostStep, shape, context);
	}
}
예제 #14
0
// adds nonstatic circle shape to space
// currently does not rotate
static cpShape *core_add_circle_shape ( cpSpace *space, Circle * circ, const int index ) {
    
    // calculate mass and moment of circle
    cpFloat mass = circ->density * M_PI * circ->radius * circ->radius;
    cpFloat moment = cpMomentForCircle ( mass, 0, circ->radius, cpvzero );
    
    // add body with mass and moment of a circle to space
    cpBody *body = cpBodyNew ( mass, moment );
    cpSpaceAddPostStepCallback ( space, (cpPostStepFunc) postStepAddBody, body, NULL );
    cpBodySetPos ( body, cpv ( circ->x, circ->y ) );
    
    // set index of body
    BodyInfo * bi = body_info_new(0);
    bi->index = index;
    bi->type = CIRCLE_TYPE;
    bi->p1x = circ->x - (circ->radius);
    bi->p1y = circ->y + (circ->radius);
    bi->p2x = circ->x + (circ->radius);
    bi->p2y = circ->y - (circ->radius);
    bi->color->r = circ->color->r;
    bi->color->g = circ->color->g;
    bi->color->b = circ->color->b;
    bi->friction = circ->friction;
    bi->density = circ->density;
    bi->elasticity = circ->elasticity;
    
    body->data = bi; 
    
    // adds circle collision shape to body
    cpShape *circShape = cpCircleShapeNew ( body, circ->radius, cpvzero );
    cpSpaceAddPostStepCallback ( space, (cpPostStepFunc) postStepAddShape, circShape, NULL );
    cpShapeSetFriction ( circShape, circ->friction );
    cpShapeSetElasticity ( circShape, circ->elasticity );
    //cpShapeSetCollisionType ( circShape , TARGET_COLLISION_TYPE );
    
    DrawShapeInfo *info = add_circle_draw_shape_info ( circ );
    circShape->data= ( cpDataPointer ) info;
    return circShape;
}
예제 #15
0
void Chains::BreakableJointPostSolve(cpConstraint *joint, cpSpace *space)
{
	cpFloat dt = cpSpaceGetCurrentTimeStep(space);
	
	// Convert the impulse to a force by dividing it by the timestep.
	cpFloat force = cpConstraintGetImpulse(joint)/dt;
	cpFloat maxForce = cpConstraintGetMaxForce(joint);

	// If the force is almost as big as the joint's max force, break it.
	if(force > 0.9*maxForce){
		cpSpaceAddPostStepCallback(space, (cpPostStepFunc)BreakablejointPostStepRemove, joint, NULL);
	}
}
예제 #16
0
// adds static circle shape to space
static void core_add_static_circle_shape ( cpSpace * space, Circle * circ ) {
    
    cpVect offset = cpv ( circ->x, circ->y );
    
    // add circle collision shape to space
    cpShape * circ_shape = cpCircleShapeNew ( space->staticBody, circ->radius, offset );
    cpShapeSetFriction ( (cpShape *) circ_shape, circ->friction );
    cpShapeSetElasticity ( (cpShape *) circ_shape, circ->elasticity );
    
    cpSpaceAddPostStepCallback ( space, (cpPostStepFunc) postStepAddShape, circ_shape, NULL );    
    DrawShapeInfo *info = add_circle_draw_shape_info ( circ );
    circ_shape->data= ( cpDataPointer ) info;
    
}
예제 #17
0
void update_fist(SPRITESPTR fist)
{
    int nflags = 0;

	fist->shape->body->v = cpv(-180, 0);

    add_element_to_render_queue(fist->sdata.currentimg->image, fist->sdata.x, fist->sdata.y, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    fist->sdata.x = fist->shape->body->p.x-fist->sdata.currentimg->width/2;
    fist->sdata.y = fist->shape->body->p.y-fist->sdata.currentimg->height/2;

    if(fist->sdata.x+fist->sdata.currentimg->width <= 0)
        cpSpaceAddPostStepCallback(get_global_cpSpace(), &remove_enemy, fist, NULL);
}
예제 #18
0
void update_spikes(SPRITESPTR spikes)
{
    int nflags = 0;

	spikes->shape->body->v = cpv(-180, 0);

    add_element_to_render_queue(spikes->sdata.currentimg->image, spikes->sdata.x, spikes->sdata.y, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);
    spikes->sdata.x = spikes->shape->body->p.x-spikes->sdata.currentimg->width/2;
    spikes->sdata.y = spikes->shape->body->p.y-spikes->sdata.currentimg->height/2;

    if(spikes->sdata.x+spikes->sdata.currentimg->width <= 0)
        cpSpaceAddPostStepCallback(get_global_cpSpace(), &remove_enemy, spikes, NULL);
}
예제 #19
0
void update_raw(SPRITESPTR raw)
{
    int nflags = 0;

	raw->shape->body->v = cpv(-180, 0);

    if(raw->sdata.x <= 600 && raw->sdata.x >= 550)
    {
        set_anim_flags_on_sprite(raw, MATTACK);
    }

    add_element_to_render_queue(raw->sdata.currentimg->image, raw->sdata.x, raw->sdata.y, nflags,
                                RCOLOR(255, 255, 255, 255), NULL);

    if((raw->sdata.animflags & MATTACK))
    {
        int x = raw->sdata.x-5*raw->sdata.anim_counter;
        int y = raw->sdata.y+30;
        SIMAGEPTR lazer = search_image_list_for_element(&(raw->ifirstptr), "LAZER");
        raw->sdata.anim_counter++;
        raw->sdata.currentimg = search_image_list_for_element(&(raw->ifirstptr), "RAW_2");
        if(x+lazer->width <= raw->sdata.x)
        {
            raw->sdata.currentimg = search_image_list_for_element(&(raw->ifirstptr), "RAW_1");
        }
        if(x+lazer->width <= 0)
        {
            raw->sdata.anim_counter = 0;
            remove_anim_flags_on_sprite(raw, MATTACK);
        }
        SPRITESPTR stman = search_sprite_list_for_element("STICKMAN");
        if((x >= stman->sdata.x && x <= stman->sdata.x+stman->sdata.currentimg->width) &&
           (y >= stman->sdata.y && y <= stman->sdata.y+stman->sdata.currentimg->height) &&
           !(stman->sdata.animflags & MDAMAGED) && !(stman->sdata.animflags & MRECOVER))
        {
            lives--;
            set_anim_flags_on_sprite(stman, MDAMAGED);
            raw->sdata.anim_counter = 0;
            remove_anim_flags_on_sprite(raw, MATTACK);
        }
        add_element_to_render_queue(lazer->image, x, y, nflags,
                                    RCOLOR(255, 255, 255, 255), NULL);
    }

    raw->sdata.x = raw->shape->body->p.x-raw->sdata.currentimg->width/2;
    raw->sdata.y = raw->shape->body->p.y-raw->sdata.currentimg->height/2;

    if(raw->sdata.x+raw->sdata.currentimg->width <= 0)
        cpSpaceAddPostStepCallback(get_global_cpSpace(), &remove_enemy, raw, NULL);
}
예제 #20
0
static cpBool bulletPlaneBeginFunc(cpArbiter *arb, cpSpace *space, void*) {
    cpShape *a,*b;
    cpArbiterGetShapes(arb, &a,&b);
    cpBody *targetBody = cpShapeGetBody(b);
    if (((Bullet *)cpBodyGetUserData(cpShapeGetBody(a)))->player()->body() != targetBody) {
        printf("Hit plane\n");
        Player * player = (Player *)(cpBodyGetUserData(targetBody));
        player->hurt(200);

        cpSpaceAddPostStepCallback( space, (cpPostStepFunc)ammoFree, a, NULL);

        return true;
    }
    return false;
}
예제 #21
0
static cpBool
HookCrate(cpArbiter *arb, cpSpace *space, void *data)
{
	if(hookJoint == NULL){
		// Get pointers to the two bodies in the collision pair and define local variables for them.
		// Their order matches the order of the collision types passed
		// to the collision handler this function was defined for
		CP_ARBITER_GET_BODIES(arb, hook, crate);
		
		// additions and removals can't be done in a normal callback.
		// Schedule a post step callback to do it.
		// Use the hook as the key and pass along the arbiter.
		cpSpaceAddPostStepCallback(space, (cpPostStepFunc)AttachHook, hook, crate);
	}
	
	return cpTrue; // return value is ignored for sensor callbacks anyway
}
예제 #22
0
파일: Sticky.c 프로젝트: Adefy/AdefyiOS
static void
StickySeparate(cpArbiter *arb, cpSpace *space, void *data)
{
	cpConstraint *joint = (cpConstraint *)cpArbiterGetUserData(arb);
	
	if(joint){
		// The joint won't be removed until the step is done.
		// Need to disable it so that it won't apply itself.
		// Setting the force to 0 will do just that
		cpConstraintSetMaxForce(joint, 0.0f);
		
		// Perform the removal in a post-step() callback.
		cpSpaceAddPostStepCallback(space, PostStepRemoveJoint, joint, NULL);
		
		// NULL out the reference to the joint.
		// Not required, but it's a good practice.
		cpArbiterSetUserData(arb, NULL);
	}
}
예제 #23
0
파일: space.c 프로젝트: ashleyw/gochipmunk
inline cpBool space_add_poststep(cpSpace *space, cpDataPointer key, cpDataPointer data) {
  return cpSpaceAddPostStepCallback(space, (void *)postStep, key, data);
}
예제 #24
0
파일: Neoshooter.cpp 프로젝트: ofx/dr
void Neoshooter::Shoot(void)
{
    cpSpaceAddPostStepCallback(this->m_World->GetSpace(), ShootP, this, this->m_Owner);
}
예제 #25
0
void
cpSpacePostStepRemoveAndFreeShapeAndBody(cpSpace *space, cpShape *shape)
{
	cpSpaceAddPostStepCallback(space, (cpPostStepFunc)removeAndFreeShapeAndBody, shape, space);
}
예제 #26
0
static void postShapeFree(cpShape *shape, cpSpace *space){
	cpSpaceAddPostStepCallback(space, (cpPostStepFunc)shapeFreeWrap, shape, NULL);
}
예제 #27
0
static void postBodyFree(cpBody *body, cpSpace *space){
	cpSpaceAddPostStepCallback(space, (cpPostStepFunc)bodyFreeWrap, body, NULL);
}
예제 #28
0
static void postConstraintFree(cpConstraint *constraint, cpSpace *space){
	cpSpaceAddPostStepCallback(space, (cpPostStepFunc)constraintFreeWrap, constraint, NULL);
}
예제 #29
0
cpBool Space::addPostStepCallback(cpPostStepFunc func,void *key,void *data)
{
		return cpSpaceAddPostStepCallback(space,func,key,data);
}
예제 #30
0
cpBool Space::addPostStepCallback(PostStepFunc func,void *key)
{
		return cpSpaceAddPostStepCallback(space,*SpaceAddPostStepCallback,key,&func);
}