[nacltoons] Use box2d sensors to detect collisions.

nacltoons/src/physics_layer.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "physics_layer.h"
 #include "gameplay_scene.h"
 
 #include "physics_nodes/CCPhysicsSprite.h"
 #include "CCLuaEngine.h"
 #include "LuaBox2D.h"
@@ skipping 37 matching lines @@
   current_instance_ = this;
 
   setTouchEnabled(true);
 
   InitPhysics();
 
   // load level from lua file.
   LoadLua();
 
   // calculate brush size
-  brush_ = (CCSprite*)getChildByTag(TAG_BRUSH);
-  assert(brush_);
+  CCSpriteBatchNode* brush_batch = (CCSpriteBatchNode*)getChildByTag(TAG_BRUSH);
+  assert(brush_batch);
+  brush_ = CCSprite::createWithTexture(brush_batch->getTexture());
+  brush_->retain();
   CCSize brush_size = brush_->getContentSize();
   brush_radius_ = MAX(brush_size.height/2, brush_size.width/2);
 
   // script physics updates each frame
   schedule(schedule_selector(PhysicsLayer::UpdateWorld));
   return true;
 }
 
 PhysicsLayer::PhysicsLayer() :
    goal_reached_(false),
    current_touch_id_(-1),
    render_target_(NULL),
    box2d_density_(DEFAULT_DENSITY),
    box2d_restitution_(DEFAULT_RESTITUTION),
    box2d_friction_(DEFAULT_FRICTION),
 #ifdef COCOS2D_DEBUG
    debug_enabled_(false)
 #endif
 {
   memset(stars_collected_, 0, sizeof(stars_collected_));
 }
 
 PhysicsLayer::~PhysicsLayer() {
+  brush_->release();
   if (current_instance_ == this)
     current_instance_ = NULL;
   delete box2d_world_;
 #ifdef COCOS2D_DEBUG
   delete box2d_debug_draw_;
 #endif
 }
 
 void PhysicsLayer::registerWithTouchDispatcher()
 {
@@ skipping 64 matching lines @@
   b2Body* ground_body = box2d_world_->CreateBody(&ground_def);
 
   CCLog("origin: %.fx%.f", origin.x, origin.y);
   CCLog("size: %.fx%f", visible_size.width, visible_size.height);
 
   // Define the ground box shape.
   b2EdgeShape ground_box;
   ground_box.Set(b2Vec2(0, 0), b2Vec2(world_width, 0));
   ground_body->CreateFixture(&ground_box, 0);
 
+  box2d_world_->SetContactListener(this);
+
 #ifdef COCOS2D_DEBUG
   box2d_debug_draw_ = new GLESDebugDraw(PTM_RATIO);
   box2d_world_->SetDebugDraw(box2d_debug_draw_);
 
   uint32 flags = 0;
   flags += b2Draw::e_shapeBit;
   flags += b2Draw::e_jointBit;
   flags += b2Draw::e_centerOfMassBit;
   //flags += b2Draw::e_aabbBit;
   //flags += b2Draw::e_pairBit;
@@ skipping 21 matching lines @@
 CCRect CalcBoundingBox(CCSprite* sprite) {
   CCSize size = sprite->getContentSize();
   CCPoint pos = sprite->getPosition();
   return CCRectMake(pos.x - size.width, pos.y - size.height,
                     size.width, size.height/2);
 }
 
 void PhysicsLayer::UpdateWorld(float dt) {
   // update physics
   box2d_world_->Step(dt, VELOCITY_ITERATIONS, POS_ITERATIONS);
+}
 
-  CCSprite* ball = (CCSprite*)getChildByTag(TAG_BALL);
-  assert(ball);
-  CCRect ball_bounds = CalcBoundingBox(ball);
+void PhysicsLayer::BeginContact(b2Contact* contact) {
+  CCPhysicsSprite* ball = (CCPhysicsSprite*)getChildByTag(TAG_BALL);
+  b2Body* ball_body = ball->getB2Body();
+  b2Body* body1 = contact->GetFixtureA()->GetBody();
+  b2Body* body2 = contact->GetFixtureB()->GetBody();
+  b2Body* body_other = NULL;
 
-  // TODO(sbc): Investigate using box2d to do collision for us
-  // http://www.iforce2d.net/b2dtut/sensors
+  if (body1 == ball_body)
+    body_other = body2;
+  else if (body2 == ball_body)
+    body_other = body1;
+  else // we are only interested in collisions involving the ball
+    return;
 
-  // check for stars being reached by ball
   int star_tags[] = { TAG_STAR1, TAG_STAR2, TAG_STAR3 };
   for (uint i = 0; i < sizeof(star_tags)/sizeof(int); i++) {
     if (stars_collected_[i])
       continue;
-    CCSprite* star = (CCSprite*)getChildByTag(star_tags[i]);
-    assert(star);
-    CCRect star_bounds = CalcBoundingBox(star);
-
-    if (ball_bounds.intersectsRect(star_bounds)) {
+    CCPhysicsSprite* star = (CCPhysicsSprite*)getChildByTag(star_tags[i]);
+    if (body_other == star->getB2Body()) {
       CCLog("star %d reached", i);
       stars_collected_[i] = true;
       CCAction* action = CCFadeOut::create(0.5f);
       star->runAction(action);
     }
   }
 
-  // check for goal being reached by ball
-  if (!goal_reached_) {
-    CCSprite* goal = (CCSprite*)getChildByTag(TAG_GOAL);
-    assert(goal);
-    CCRect goal_bounds = CalcBoundingBox(goal);
-    if (ball_bounds.intersectsRect(goal_bounds)) {
+  if (!goal_reached_)
+  {
+    CCPhysicsSprite* goal = (CCPhysicsSprite*)getChildByTag(TAG_GOAL);
+    if (body_other == goal->getB2Body()) {
       CCLog("goal reached");
       goal_reached_ = true;
 
       // fade out the goal and trigger gameover callback when its
       // done
       CCActionInterval* fadeout = CCFadeOut::create(0.5f);
       CCFiniteTimeAction* fadeout_done = CCCallFuncN::create(this,
-           callfuncN_selector(PhysicsLayer::LevelComplete));
+          callfuncN_selector(PhysicsLayer::LevelComplete));
       CCSequence* seq = CCSequence::create(fadeout, fadeout_done, NULL);
       goal->runAction(seq);
     }
   }
 }
 
 void PhysicsLayer::LevelComplete(CCNode* sender) {
   unschedule(schedule_selector(PhysicsLayer::UpdateWorld));
   setTouchEnabled(false);
   GameplayScene* scene = static_cast<GameplayScene*>(getParent());
@@ skipping 276 matching lines @@
   float posx = SCREEN_TO_WORLD((sx+ex)/2) - body->GetPosition().x;
   float posy = SCREEN_TO_WORLD((sy+ey)/2) - body->GetPosition().y;
 
   float width = SCREEN_TO_WORLD(abs(distance));
   float height = SCREEN_TO_WORLD(brush_->boundingBox().size.height);
 
   b2PolygonShape shape;
   shape.SetAsBox(width / 2, height / 2, b2Vec2(posx, posy), angle);
   AddShapeToBody(body, &shape);
 }