cocs2d-x 学习例子 box2d 实现类似愤怒的小鸟的简单参考例子

最新推荐文章于 2018-11-20 15:54:00 发布
最新推荐文章于 2018-11-20 15:54:00 发布
阅读量1.2k 收藏
点赞数
分类专栏： Android 文章标签： cocos2d-x Box2D
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/serika00/article/details/9744613
版权

首先贴出最初的出处：http://www.raywenderlich.com/4756/how-to-make-a-catapult-shooting-game-with-cocos2d-and-box2d-part-1

再贴出我主要参考的贴：http://mssyy2010.blog.51cto.com/4595971/847000

然后是我稍加调整后可以在cocos2d-2.14编译运行的代码（整个vs project包括resources)：https://github.com/serika00/android/tree/master/cocos2d-x/CatapultShootingGame


再顺手把代码贴上，原来两个出处解释得都比较清楚了，不多加解释。


HelloWorld.h

#ifndef __HELLOWORLD_SCENE_H__
#define __HELLOWORLD_SCENE_H__

#include "cocos2d.h"
#include "Box2D/Box2D.h"
#include "MyContactListener.h"

USING_NS_CC;

class HelloWorld : public cocos2d::CCLayer
{
public:
    // Here's a difference. Method 'init' in cocos2d-x returns bool, instead of returning 'id' in cocos2d-iphone
    virtual bool init();  

    // there's no 'id' in cpp, so we recommend returning the class instance pointer
    static cocos2d::CCScene* scene();
    
    // a selector callback
    void menuCloseCallback(CCObject* pSender);
    
    // implement the "static node()" method manually
    CREATE_FUNC(HelloWorld);

	HelloWorld() {};
	~HelloWorld();
	void tick(float dt);
	void ccTouchesBegan(CCSet* pTouches, CCEvent* pEvent);
	void ccTouchesMoved(CCSet* pTouches, CCEvent* pEvent);
	void ccTouchesEnded(CCSet* pTouches, CCEvent* pEvent);
	void createBullets(int count);
	bool attachBullet();
	void resetGame();
	void createTarget(char   *imageName,
					  CCPoint position,
					  float   rotation,
					  bool	  isCircle,
					  bool    isStatic,
					  bool    isEnemy);
	void createTargets();
	void resetBullet();
private:
	b2World* m_world;
	b2Body* m_groundBody;
	b2RevoluteJoint *m_armJoint;
	b2MouseJoint *m_mouseJoint;
	b2Fixture* m_armFixture;
	b2Body* m_armBody;
	std::vector<b2Body*> m_bullets;
	int m_currentBullet;
	b2Body* m_bulletBody;
	b2WeldJoint* m_bulletJoint;
	bool m_releasingArm;
	vector<b2Body*> *targets;
	vector<b2Body*> *enemies;
	MyContactListener* contactListener;
};

#endif // __HELLOWORLD_SCENE_H__


HelloWorld.cpp

#include "HelloWorldScene.h"
#define PTM_RATIO 32
#define FLOOR_HEIGHT 62.0f

USING_NS_CC;

CCScene* HelloWorld::scene()
{
    // 'scene' is an autorelease object
    CCScene *scene = CCScene::create();
    
    // 'layer' is an autorelease object
    HelloWorld *layer = HelloWorld::create();

    // add layer as a child to scene
    scene->addChild(layer);

    // return the scene
    return scene;
}

// on "init" you need to initialize your instance
bool HelloWorld::init()
{
    //
    // 1. super init first
	targets = new vector<b2Body*>;
	enemies = new vector<b2Body*>;
    CCSprite* sprite1 = CCSprite::create("bg.png");
	sprite1->setAnchorPoint(CCPointZero);
	addChild(sprite1, -1);

	CCSprite* sprite2 = CCSprite::create("catapult_base_2.png");
	sprite2->setAnchorPoint(CCPointZero);
	sprite2->setPosition(CCPointMake(181.0, FLOOR_HEIGHT));
	addChild(sprite2, 0);

	CCSprite* sprite3 = CCSprite::create("squirrel_1.png");
	sprite3->setAnchorPoint(CCPointZero);
	sprite3->setPosition(CCPointMake(11.0, FLOOR_HEIGHT));
	addChild(sprite3, 0);

	CCSprite* sprite4 = CCSprite::create("catapult_base_1.png");
	sprite4->setAnchorPoint(CCPointZero);
	sprite4->setPosition(CCPointMake(181.0, FLOOR_HEIGHT));
	addChild(sprite4, 9);

	CCSprite* sprite5 = CCSprite::create("squirrel_2.png");
	sprite5->setAnchorPoint(CCPointZero);
	sprite5->setPosition(CCPointMake(240.0, FLOOR_HEIGHT));
	addChild(sprite5, 9);

	CCSprite* sprite6 = CCSprite::create("fg.png");
	sprite6->setAnchorPoint(CCPointZero);
	addChild(sprite6, 10);

	b2Vec2 gravity;
	gravity.Set(0.0f, -10.0f);
	m_world = new b2World(gravity);
	m_world->SetAllowSleeping(true);
	m_world->SetContinuousPhysics(true);

	b2BodyDef groundBodyDef;
	groundBodyDef.position.Set(0, 0);
	m_groundBody = m_world->CreateBody(&groundBodyDef);

	b2EdgeShape groundBox;
	CCSize screenSize = CCDirector::sharedDirector()->getWinSize();

	 groundBox.Set(b2Vec2(0,FLOOR_HEIGHT/PTM_RATIO), b2Vec2(screenSize.width*2.0f/PTM_RATIO,FLOOR_HEIGHT/PTM_RATIO)); 
    m_groundBody->CreateFixture(&groundBox, 0); 
     
    // top 
    groundBox.Set(b2Vec2(0,screenSize.height/PTM_RATIO), b2Vec2(screenSize.width*2.0f/PTM_RATIO,screenSize.height/PTM_RATIO)); 
    m_groundBody->CreateFixture(&groundBox, 0); 
     
    // left 
    groundBox.Set(b2Vec2(0,screenSize.height/PTM_RATIO), b2Vec2(0,0)); 
    m_groundBody->CreateFixture(&groundBox, 0); 
     
    // right 
//    groundBox.Set(b2Vec2(screenSize.width*1.5f/PTM_RATIO,screenSize.height/PTM_RATIO), b2Vec2(screenSize.width*1.5f/PTM_RATIO,0)); 
//    m_groundBody->CreateFixture(&groundBox, 0); 

    
	CCSprite *arm = CCSprite::create("catapult_arm.png");
	addChild(arm, 1);
	b2BodyDef armBodyDef;
	armBodyDef.type = b2_dynamicBody;
	armBodyDef.linearDamping = 1;
	armBodyDef.angularDamping = 1;
	armBodyDef.position.Set(230.0f/PTM_RATIO, (FLOOR_HEIGHT+91.0f)/PTM_RATIO);
	armBodyDef.userData = arm;
	m_armBody = m_world->CreateBody(&armBodyDef);

	b2PolygonShape armBox;
	b2FixtureDef armBoxDef;
	armBoxDef.shape = &armBox;
	armBoxDef.density = 0.3f;
	armBox.SetAsBox(11.0f/PTM_RATIO, 91.0f/PTM_RATIO);
	m_armFixture = m_armBody->CreateFixture(&armBoxDef);


	b2RevoluteJointDef armJointDef;
	armJointDef.Initialize(m_groundBody, m_armBody,
		b2Vec2(233.0f / PTM_RATIO, 50/PTM_RATIO));
	armJointDef.enableMotor = true;
	armJointDef.enableLimit = true;
	armJointDef.motorSpeed = -10;
	armJointDef.lowerAngle = CC_DEGREES_TO_RADIANS(9);
	armJointDef.upperAngle = CC_DEGREES_TO_RADIANS(75);
	armJointDef.maxMotorTorque = 700;
	m_armJoint = (b2RevoluteJoint*) m_world->CreateJoint(&armJointDef);
	
	m_mouseJoint = NULL;

	resetGame();
	m_releasingArm = false;
	createTargets();

	contactListener = new MyContactListener();
	m_world->SetContactListener(contactListener);

	setTouchEnabled(true);
	schedule(schedule_selector(HelloWorld::tick));
    return true;
}


void HelloWorld::menuCloseCallback(CCObject* pSender)
{
    CCDirector::sharedDirector()->end();

#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
    exit(0);
#endif
}

void HelloWorld::tick(float dt) {
	int velocityIterations = 8;
	int positionIterations = 1;
	
	m_world->Step(dt, velocityIterations, positionIterations);
	for (b2Body* b = m_world->GetBodyList(); b; b = b->GetNext()) {
		if (b->GetUserData() != NULL) {
			CCSprite* sprite = (CCSprite*)(b->GetUserData());
			sprite->setPosition(ccp(b->GetPosition().x * PTM_RATIO, b->GetPosition().y * PTM_RATIO));
			sprite->setRotation( -1 * CC_RADIANS_TO_DEGREES(b->GetAngle()));
			
		}
	}
	if (m_releasingArm && m_bulletJoint != NULL) {
		if (m_armJoint->GetJointAngle() <= CC_DEGREES_TO_RADIANS(10)) {
			m_releasingArm = false;
			m_world->DestroyJoint(m_bulletJoint);
			m_bulletJoint = NULL;

			CCDelayTime* delayAction = CCDelayTime::create(5.0f);
			CCCallFunc* callSelectorAction = CCCallFunc::create(this, callfunc_selector(HelloWorld::resetBullet));
			this->runAction(CCSequence::create(delayAction, callSelectorAction, NULL));
		}
	}
	if (m_bulletBody && m_bulletJoint == NULL) {
		b2Vec2 position = m_bulletBody->GetPosition();
		CCPoint myPosition = this->getPosition();
		CCSize screenSize = CCDirector::sharedDirector()->getWinSize();
		if (position.x > screenSize.width/2.0f/PTM_RATIO) {
			myPosition.x = -MIN(screenSize.width*2.0f - screenSize.width,
				position.x*PTM_RATIO - screenSize.width/2.0f);
			this->setPosition(myPosition);
		}
	}
    std::set<b2Body*>::iterator pos;
	for (pos = contactListener->contacts.begin(); pos != contactListener->contacts.end(); ++pos) {
		b2Body* body = *pos;
		for (vector<b2Body*>::iterator iter = targets->begin(); iter != targets->end(); ++iter) {
			if (body == *iter) {
				iter = targets->erase(iter);
				break;
			}
		}
		for (vector<b2Body*>::iterator iter = enemies->begin(); iter != enemies->end(); ++iter) {
			if (body == *iter) {
				iter = enemies->erase(iter);
				break;
			}
		}
		CCNode* contactNode = (CCNode*)body->GetUserData();
		CCPoint position = contactNode->getPosition();
		removeChild(contactNode, true);
		m_world->DestroyBody(body);

		CCParticleSun *explosion = CCParticleSun::create();
		explosion->retain();
		explosion->setTexture(CCTextureCache::sharedTextureCache()->addImage("fire.png"));
//		explosion->initWithTotalParticles(200);
		explosion->setAutoRemoveOnFinish(true);
		explosion->setStartSizeVar(10.0f);
		explosion->setSpeed(70.0f);
		explosion->setAnchorPoint(ccp(0.5f, 0.5f));
		explosion->setPosition(position);
		explosion->setDuration(1.0f);
		addChild(explosion, 11);
		explosion->release();
	}
	contactListener->contacts.clear();
}

void HelloWorld::ccTouchesBegan(CCSet* pTouches, CCEvent* pEvent) {
	if (m_mouseJoint != NULL) { return; }
	CCTouch* touch = (CCTouch*)pTouches->anyObject();
	CCPoint location = touch->getLocation();
	location = CCDirector::sharedDirector()->convertToGL(location);
	b2Vec2 locationWorld = b2Vec2(location.x/PTM_RATIO, location.y/PTM_RATIO);

	if (locationWorld.x < m_armBody->GetWorldCenter().x + 150.0/PTM_RATIO) {
		b2MouseJointDef md;
		md.bodyA = m_groundBody;
		md.bodyB = m_armBody;
		md.target = locationWorld;
		md.maxForce = 2000;

		m_mouseJoint = (b2MouseJoint*)m_world->CreateJoint(&md);
	}
}

void HelloWorld::ccTouchesMoved(CCSet* pTouches, CCEvent* pEvent) {
	if (m_mouseJoint == NULL) { return; }

	CCTouch* touch = (CCTouch*)pTouches->anyObject();
	CCPoint location = touch->getLocation();
	location = CCDirector::sharedDirector()->convertToGL(location);
	b2Vec2 locationWorld = b2Vec2(location.x/PTM_RATIO, location.y/PTM_RATIO);

	m_mouseJoint->SetTarget(locationWorld);
}

void HelloWorld::ccTouchesEnded(CCSet* pTouches, CCEvent* pEvent) {
	if (m_mouseJoint != NULL) {
		if (m_armJoint->GetJointAngle() >= CC_DEGREES_TO_RADIANS(5)) {
			m_releasingArm = true;
		}
		m_world->DestroyJoint(m_mouseJoint);
		m_mouseJoint = NULL;
		return;
	}
}

void HelloWorld::createBullets(int count) {
	m_currentBullet = 0;
	float pos = 62.0f;

	if (count > 0) {
		float delta = (count > 1) ? ((165.0f - 62.0f - 30.0f) / (count - 1)):0.0f;
		for (int i = 0; i < count; i++, pos += delta) {
			CCSprite* sprite = CCSprite::create("acorn.png");
			addChild(sprite, 1);

			b2BodyDef bulletBodyDef;
			bulletBodyDef.type = b2_dynamicBody;
			bulletBodyDef.bullet = true;
			bulletBodyDef.position.Set(pos/PTM_RATIO, (FLOOR_HEIGHT+15.0f)/PTM_RATIO);
			bulletBodyDef.userData = sprite;
			b2Body* bullet = m_world->CreateBody(&bulletBodyDef);
			bullet->SetActive(false);

			b2CircleShape circle;
			circle.m_radius = 15.0/PTM_RATIO;

			b2FixtureDef ballShapeDef;
			ballShapeDef.shape = &circle;
			ballShapeDef.density = 0.8f;
			ballShapeDef.restitution = 0.2f;
			ballShapeDef.friction = 0.99f;
			bullet->CreateFixture(&ballShapeDef);
			m_bullets.push_back(bullet);
		}
	}
}

bool HelloWorld::attachBullet() {
	if (m_currentBullet < m_bullets.size()) {
		m_bulletBody = (b2Body*)m_bullets.at(m_currentBullet++);
		m_bulletBody->SetTransform(b2Vec2(230.0f/PTM_RATIO, (156.0f+FLOOR_HEIGHT)/PTM_RATIO), 0.0f);
		m_bulletBody->SetActive(true);
		b2WeldJointDef weldJointDef;
		weldJointDef.Initialize(m_bulletBody, m_armBody, b2Vec2(230.0f/PTM_RATIO, (150.0f+FLOOR_HEIGHT)/PTM_RATIO));
		weldJointDef.collideConnected = false;
		m_bulletJoint = (b2WeldJoint*)m_world->CreateJoint(&weldJointDef);
		return true;
	}
	return false;
}

void HelloWorld::resetGame() {
	if (m_bullets.size() != 0) {
		for (vector<b2Body*>::iterator bulletPointer = m_bullets.begin(); bulletPointer != m_bullets.end(); ++bulletPointer) {
			b2Body* bullet = (b2Body*)*bulletPointer;
			CCNode* node = (CCNode*)bullet->GetUserData();
			m_world->DestroyBody(bullet);
		}
		m_bullets.clear();
	}
	if (targets->end() - targets->begin() != 0) {
		for (vector<b2Body*>::iterator targetPointer = (*targets).begin(); targetPointer != (*targets).end(); targetPointer++) {
			b2Body* target = (b2Body*)*targetPointer;
			CCNode* node = (CCNode*)target->GetUserData();
			removeChild(node, true);
			m_world->DestroyBody(target);
		}
		(*targets).clear();
		(*enemies).clear();
	}

	this->createBullets(3);
	this->createTargets();
	this->attachBullet();

	CCFiniteTimeAction *action1 = CCMoveTo::create(1.5f, ccp(-480.0f, 0.0f));
//	CCCallFuncN *action2 = CCCallFuncN::create(this, callfuncN_selector(HelloWorld::attachBullet));
	CCDelayTime *action3 = CCDelayTime::create(1.0f);
	CCFiniteTimeAction* action4 = CCMoveTo::create(1.5f, CCPointZero);
	runAction(CCSequence::create(action1,action3, action4, NULL));

	
}

HelloWorld::~HelloWorld()
{
	delete m_world;
	m_world = NULL;
}

void HelloWorld::resetBullet() {
	if (enemies->size() == 0) {
		CCDelayTime* delayAction = CCDelayTime::create(2.0f);
		CCCallFunc* callSelectorAction = CCCallFunc::create(this, callfunc_selector(HelloWorld::resetGame));
		this->runAction(CCSequence::create(delayAction, callSelectorAction, NULL));
	} else if (attachBullet()) {
		CCAction *action = CCMoveTo::create(0.2f, CCPointZero);
		runAction(action);
	} else {
		CCDelayTime* delayAction = CCDelayTime::create(2.0f);
		CCCallFunc* callSelectorAction = CCCallFunc::create(this, callfunc_selector(HelloWorld::resetGame));
		this->runAction(CCSequence::create(delayAction, callSelectorAction, NULL));
	}
}

void HelloWorld::createTarget(char   *imageName,
					  CCPoint position,
					  float   rotation,
					  bool	  isCircle,
					  bool    isStatic,
					  bool    isEnemy) {

						  CCSprite *sprite = CCSprite::create(imageName); 
    this->addChild(sprite, 1); 
 
    b2BodyDef bodyDef; 
    bodyDef.type = isStatic ? b2_staticBody : b2_dynamicBody; 
    bodyDef.position.Set((position.x+sprite->getContentSize().width/2.0f)/PTM_RATIO, 
                                     (position.y+sprite->getContentSize().height/2.0f)/PTM_RATIO); 
    bodyDef.angle = CC_DEGREES_TO_RADIANS(rotation); 
    bodyDef.userData = sprite; 
 
    b2Body *body = m_world->CreateBody(&bodyDef); 
 
    b2FixtureDef boxDef; 
    b2Fixture *fixtureTemp; 
     
    if (isCircle){ 
        b2CircleShape circle; 
        boxDef.shape = &circle; 
        circle.m_radius = sprite->getContentSize().width/2.0f/PTM_RATIO; 
         
        fixtureTemp = body->CreateFixture(&circle, 0.5f); 
        targets->push_back(body); 
    } 
    else{ 
        b2PolygonShape box; 
        boxDef.shape = &box; 
        box.SetAsBox(sprite->getContentSize().width/2.0f/PTM_RATIO, sprite->getContentSize().height/2.0f/PTM_RATIO); 
        body->CreateFixture(&box, 0.5f); 
        targets->push_back(body); 
    } 
 
    if (isEnemy){ 
        fixtureTemp->SetUserData((void*)1);     //  boxDef.userData = (void*)1; 
        enemies->push_back(body); 
    } 
}

void HelloWorld::createTargets() {
	createTarget("brick_2.png", CCPointMake(675.0, FLOOR_HEIGHT), 0.0f, false, false, false); 
    createTarget("brick_1.png", CCPointMake(741.0, FLOOR_HEIGHT), 0.0f, false, false, false); 
    createTarget("brick_1.png", CCPointMake(741.0, FLOOR_HEIGHT+23.0), 0.0f, false, false, false); 
    createTarget("brick_3.png", CCPointMake(673.0, FLOOR_HEIGHT+46.0), 0.0f, false, false, false); 
    createTarget("brick_1.png", CCPointMake(707.0, FLOOR_HEIGHT+58.0), 0.0f, false, false, false); 
    createTarget("brick_1.png", CCPointMake(707.0, FLOOR_HEIGHT+81.0), 0.0f, false, false, false); 
 
    createTarget("head_dog.png", CCPointMake(702.0, FLOOR_HEIGHT), 0.0f, true, false, true); 
    createTarget("head_cat.png", CCPointMake(680.0, FLOOR_HEIGHT+58.0), 0.0f, true, false, true); 
    createTarget("head_dog.png", CCPointMake(740.0, FLOOR_HEIGHT+58.0), 0.0f, true, false, true); 
 
    // 2 bricks at the right of the first block 
    createTarget("brick_2.png", CCPointMake(770.0, FLOOR_HEIGHT), 0.0f, false, false, false); 
    createTarget("brick_2.png", CCPointMake(770.0, FLOOR_HEIGHT+46.0), 0.0f, false, false, false); 
 
    // The dog between the blocks 
    createTarget("head_dog.png", CCPointMake(830.0, FLOOR_HEIGHT), 0.0f, true, false, true); 
 
    // Second block 
    createTarget("brick_platform.png", CCPointMake(839.0, FLOOR_HEIGHT), 0.0f, false, true, false); 
    createTarget("brick_2.png", CCPointMake(854.0, FLOOR_HEIGHT+28.0), 0.0f, false, false, false); 
    createTarget("brick_2.png", CCPointMake(854.0, FLOOR_HEIGHT+28.0+46.0), 0.0f, false, false, false); 
    createTarget("head_cat.png", CCPointMake(881.0, FLOOR_HEIGHT+28.0), 0.0f, true, false, true); 
    createTarget("brick_2.png", CCPointMake(909.0, FLOOR_HEIGHT+28.0), 0.0f, false, false, false); 
    createTarget("brick_1.png", CCPointMake(909.0, FLOOR_HEIGHT+28.0+46.0), 0.0f, false, false, false); 
    createTarget("brick_1.png", CCPointMake(909.0, FLOOR_HEIGHT+28.0+46.0+23.0), 0.0f, false, false, false); 
    createTarget("brick_2.png", CCPointMake(882.0, FLOOR_HEIGHT+108.0), 90.0f, false, false, false); 
	
}

MyContactListener.h 

#ifndef __MYCONTACTLISTENER_H__
#define __MYCONTACTLISTENER_H__

#include "Box2D/Box2D.h"
#include <set>
#include <algorithm>

class MyContactListener: public b2ContactListener {
public:
	std::set<b2Body*> contacts;
	MyContactListener();
	~MyContactListener();

	virtual void BeginContact(b2Contact* contact);
	virtual void EndContact(b2Contact* contact);
	virtual void PreSolve(b2Contact* contact, const b2Manifold* oldManifold);
	virtual void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse);

};

#endif


MyContactListener.cpp

#include "MyContactListener.h"

MyContactListener::MyContactListener():contacts() {}
MyContactListener::~MyContactListener() {}

void MyContactListener::BeginContact(b2Contact* contact) {}
void MyContactListener::EndContact(b2Contact* contact) {}
void MyContactListener::PreSolve(b2Contact* contact, const b2Manifold* oldManifold) {}
void MyContactListener::PostSolve(b2Contact* contact, const b2ContactImpulse* impulse) {
	bool isAEnemy = (contact->GetFixtureA()->GetUserData() != NULL);
	bool isBEnemy = (contact->GetFixtureB()->GetUserData() != NULL);
	if (isAEnemy || isBEnemy) {
		int32 count = contact->GetManifold()->pointCount;
		float32 maxImpulse = 0.0f;
		for (int32 i = 0; i < count; ++i) {
			maxImpulse = b2Max(maxImpulse, impulse->normalImpulses[i]);
		}
		if (maxImpulse > 1.0f) {
			if (isAEnemy) contacts.insert(contact->GetFixtureA()->GetBody());
			if (isBEnemy) contacts.insert(contact->GetFixtureB()->GetBody());
		}
	}
}


keepiton
关注
专栏目录
ERROR: Failed building wheel for box2d-py 解决方法
Laurence的技术博客
12-15 6240
而swig并不是一个python库，应该说算是一个系统级别的库，在Linux，Windows和Mac上都有不同的发行包，无法通过pip自动安装。所以，在初次构建依赖到gym的Python项目时就会遇到“ERROR: Failed building wheel for box2d-py”错误，原因就是本地操作系统上没有安装swig。此外：网上有文章提到的：手动安装box2d的做法并不适用本文所说的情况，经过测试，box2d-py作为一个Python库是可以被pip自动安装的，并不是需要手动安装。
Box2D 实现的愤怒的小鸟
12-02
利用BOX2D 实现的安卓愤怒的小鸟，
Cocos2d Box2d 物理引擎实现愤怒的小鸟
解锁密码的专栏
12-20 3266
Cocos2d  Box2d 物理引擎实现愤怒的小鸟   这里我们修改HelloWorldScene场景，在这里实现 我们的思路是首先初始化一些刚体，，然后实现点击屏幕产生小鸟，松开小鸟，小鸟飞出，撞击初始化好的那些刚体，产生碰撞检测效果。 1.在HelloWorld.h中 #include"cocos2d.h" #include"box2d/box2d.h" USING_NS_
利用Jbox2D物理引擎实现愤怒的小鸟
Hi~Future
06-20 2198
要导入jar包：jbox2d-library-2.2.1.1.jar 1、
基于Cocos2dx + box2d 实现的愤怒的小鸟Demo
04-01
压缩文件目录内容： AngryBird source 愤怒的小鸟Demo源代码，基于Cocos2dx C++，box2d技术。 run 可执行程序目录
愤怒的小鸟物理引擎Box2D(c++)带文档
12-01
著名的愤怒的小鸟物理引擎Box2D(c++)带文档，附带vc++工程。可直接用vc7.0编译
cocos2d-x游戏《box2d桌球》完整
05-15
——Box2D 是一套基于刚体模拟的物理引擎，它的核心概念为世界、物体、形状、约束和关节，这些概念具体实现为Box2D 的各个组件：·刚体(rigid body)：不会发生形变的物体，其任何两点间的距离是不变的。·形状(shape...
二人斗地主-cocs2d-lua
10-15
【二人斗地主-cocs2d-lua】是一款基于Cocos2D-Lua游戏引擎开发的双人斗地主游戏。Cocos2D-Lua是一个轻量级的2D游戏开发框架，它允许开发者使用Lua脚本语言进行游戏逻辑编写，从而提高了开发效率和代码的可读性。Lua...
Cocos2d-x学习资料汇总
07-23
x学习资料汇总【】(译)cocos2d菜单教程：第一部分【】cocos2d-iPhone_Programming_Guide【】cocos2d-x2.0射击游戏实现沈大海【】cocos2d-x2.0版本自适应屏幕分辨率AutoScaleTest【】Cocos2d-x_HelloCpp_架构分析【】...
cocs2d-iphone 的小游戏
06-05
5. **物理引擎**：虽然Cocos2d-iPhone自身不包含物理引擎，但可以集成如Box2D这样的第三方物理引擎，实现物体碰撞检测和物理行为模拟。 6. **音频管理**：Cocos2d-iPhone支持音频播放，包括背景音乐和音效，理解...
Box2dWeb包
02-03
HTML5 Canvas开发物理引擎Box2dWeb
html5游戏开发-愤怒的小鸟-开源讲座(一)-跳入弹出的小鸟
duoerbasilu
07-23 272
愤怒的小鸟是一款人气火爆的益智游戏，现在我试着用lufylegend库件和Box2dWeb物理引擎来看看在html5中如何制作此类经典的物理游戏。 准备工作一 首先，你需要下载lufylegend库件1.4.1版 http://blog.csdn.net/lufy_legend/article/details/7751425 box2dweb你可以到这里下载 http://code.google...
类似愤怒小鸟的飞行弹道
游戏路上的小学生
04-15 2551
抛体运动的类型：        "很多子弹不仅垂直运动而且追随着水平的运动。那就，当他们向上移动或向下运动时也正在水平方向移动。弹体的运动 — — 横向和纵向运动的两个组成部分。 垂直运动：              在垂直运动，重力作用在物体上，并给予负加速度"-9.8 m/s²"(重心加速度)。这意味着物体的速度在每一秒减小-9.8 米/² 。自由落体的速度是 V = g * t。 如果我
android 类似于愤怒的小鸟的游戏源码案例
weixin_34378969的博客
07-17 238
2019独角兽企业重金招聘Python工程师标准>>> ...
cocs2d-js 3.0 js与c++交互
qwezcl的专栏
11-18 1131
以前也写过js与c++的交互不过那是cocosd
android愤怒小鸟游戏、自定义View、掌上餐厅App、OpenGL自定义气泡、抖音电影滤镜效果等源码...
weixin_33758863的博客
11-20 384
2019独角兽企业重金招聘Python工程师标准>>> ...
高仿精仿愤怒的小鸟android版游戏源码
安卓源码，安卓开发资源，android游戏开发
09-23 1565
这是一款很完美的高仿精仿愤怒的小鸟android版游戏源码，大家可以研究一下吧、 为了报复偷走鸟蛋的肥猪们，鸟儿以自己的身体为武器，仿佛炮弹一样去攻击肥猪们的堡垒。游戏是十分卡通的2D画面，看着愤怒的红色小鸟，奋不顾身的往绿色的肥猪的堡垒砸去，那种奇妙的感觉还真是令人感到很欢乐。而游戏的配乐同样充满了欢乐的感觉，轻松的节奏，欢快的风格。
Box2D
maikforever 的专栏
05-22 1444
目录 box2d box2d安装 基本用法 高级话题 编辑本段box2d Box2D是一个用于模拟2D刚体物体的C++引擎。作者为Erin Catto。Box2D使用zlib许可。zlib许可是一个自由软件授权协议，但并非copyleft。 它已被用于蜡笔物理学、愤怒的小鸟、Rolando、Fantastic Contraption、Incre
Box2d中刚体的纹理的几种实现方式
Han的小站
01-03 1106
总结了下面几种为刚体添加纹理的思路
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值