axmol/tests/cpp-tests/Classes/ChipmunkTestBed/demo/Crane.c

/* Copyright (c) 2007 Scott Lembcke
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include "chipmunk/chipmunk.h"
#include "ChipmunkDemo.h"

static cpBody* dollyBody = NULL;
// Constraint used as a servo motor to move the dolly back and forth.
static cpConstraint* dollyServo = NULL;

// Constraint used as a winch motor to lift the load.
static cpConstraint* winchServo = NULL;

// Temporary joint used to hold the hook to the load.
static cpConstraint* hookJoint = NULL;

static void update(cpSpace* space, double dt)
{
    // Set the first anchor point (the one attached to the static body) of the dolly servo to the mouse's x position.
    cpPivotJointSetAnchorA(dollyServo, cpv(ChipmunkDemoMouse.x, 100));

    // Set the max length of the winch servo to match the mouse's height.
    cpSlideJointSetMax(winchServo, cpfmax(100 - ChipmunkDemoMouse.y, 50));

    if (hookJoint && ChipmunkDemoRightClick)
    {
        cpSpaceRemoveConstraint(space, hookJoint);
        cpConstraintFree(hookJoint);
        hookJoint = NULL;
    }

    cpSpaceStep(space, dt);
}

enum COLLISION_TYPES
{
    HOOK_SENSOR = 1,
    CRATE,
};

static void AttachHook(cpSpace* space, cpBody* hook, cpBody* crate)
{
    hookJoint = cpSpaceAddConstraint(space, cpPivotJointNew(hook, crate, cpBodyGetPosition(hook)));
}

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
}

static cpSpace* init(void)
{
    ChipmunkDemoMessageString = "Control the crane by moving the mouse. Right click to release.";

    cpSpace* space = cpSpaceNew();
    cpSpaceSetIterations(space, 30);
    cpSpaceSetGravity(space, cpv(0, -100));
    cpSpaceSetDamping(space, 0.8);

    cpBody* staticBody = cpSpaceGetStaticBody(space);
    cpShape* shape;

    shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, cpv(-320, -240), cpv(320, -240), 0.0f));
    cpShapeSetElasticity(shape, 1.0f);
    cpShapeSetFriction(shape, 1.0f);
    cpShapeSetFilter(shape, NOT_GRABBABLE_FILTER);

    // Add a body for the dolly.
    dollyBody = cpSpaceAddBody(space, cpBodyNew(10, INFINITY));
    cpBodySetPosition(dollyBody, cpv(0, 100));

    // Add a block so you can see it.
    cpSpaceAddShape(space, cpBoxShapeNew(dollyBody, 30, 30, 0.0));

    // Add a groove joint for it to move back and forth on.
    cpSpaceAddConstraint(space, cpGrooveJointNew(staticBody, dollyBody, cpv(-250, 100), cpv(250, 100), cpvzero));

    // Add a pivot joint to act as a servo motor controlling it's position
    // By updating the anchor points of the pivot joint, you can move the dolly.
    dollyServo = cpSpaceAddConstraint(space, cpPivotJointNew(staticBody, dollyBody, cpBodyGetPosition(dollyBody)));
    // Max force the dolly servo can generate.
    cpConstraintSetMaxForce(dollyServo, 10000);
    // Max speed of the dolly servo
    cpConstraintSetMaxBias(dollyServo, 100);
    // You can also change the error bias to control how it slows down.
    // cpConstraintSetErrorBias(dollyServo, 0.2);

    // Add the crane hook.
    cpBody* hookBody = cpSpaceAddBody(space, cpBodyNew(1, INFINITY));
    cpBodySetPosition(hookBody, cpv(0, 50));

    // Add a sensor shape for it. This will be used to figure out when the hook touches a box.
    shape = cpSpaceAddShape(space, cpCircleShapeNew(hookBody, 10, cpvzero));
    cpShapeSetSensor(shape, cpTrue);
    cpShapeSetCollisionType(shape, HOOK_SENSOR);

    // Add a slide joint to act as a winch motor
    // By updating the max length of the joint you can make it pull up the load.
    winchServo = cpSpaceAddConstraint(space, cpSlideJointNew(dollyBody, hookBody, cpvzero, cpvzero, 0, INFINITY));
    // Max force the dolly servo can generate.
    cpConstraintSetMaxForce(winchServo, 30000);
    // Max speed of the dolly servo
    cpConstraintSetMaxBias(winchServo, 60);

    // TODO: cleanup
    // Finally a box to play with
    cpBody* boxBody = cpSpaceAddBody(space, cpBodyNew(30, cpMomentForBox(30, 50, 50)));
    cpBodySetPosition(boxBody, cpv(200, -200));

    // Add a block so you can see it.
    shape = cpSpaceAddShape(space, cpBoxShapeNew(boxBody, 50, 50, 0.0));
    cpShapeSetFriction(shape, 0.7);
    cpShapeSetCollisionType(shape, CRATE);

    cpCollisionHandler* handler = cpSpaceAddCollisionHandler(space, HOOK_SENSOR, CRATE);
    handler->beginFunc          = (cpCollisionBeginFunc)HookCrate;

    return space;
}

static void destroy(cpSpace* space)
{
    ChipmunkDemoFreeSpaceChildren(space);
    cpSpaceFree(space);
}

ChipmunkDemo Crane = {
    "Crane", 1.0 / 60.0, init, update, ChipmunkDemoDefaultDrawImpl, destroy,
};