Сегодня, как я и обещал, мы вдохнем в наш Arcanoid жизнь. Заставим шарик двигаться, сталкиваясь с кирпичами, а кирпичи, при этом, разбиваться. В принципе, игровая физика в arcanoid не так чтобы очень сложна и вполне реализуема собственными силами. Единственный нетривиальный момент в ней — отслеживание столкновений. Но это именно то, что «взрослые» физические движки умеют лучше всего!
Так почему бы их не использовать? К тому-же, если мы оформим Box2D в виде модуля Marmalade, впоследствии, мы сможем использовать его и в других приложениях, возможно требующих более изощренной «физики». Давайте этим займемся.
Методика оформления Box2D в виде подпроекта совершенно аналогична той, которую мы использовали по отношению к LibYAML в предыдущей статье. Единственное отличие в том, что в Box2D гораздо больше исходных файлов. Поэтому, если нет желания повторять рутинное переписывание их имен в mkf-файл, уже выполненное мной, можно взять готовый модуль непосредственно с GitHub. Дистрибутив Box2D взят отсюда.
Итак, добавляем Box2D в наш проект:
arcanoid.mkb
#!/usr/bin/env mkb
options
{
module_path="../yaml"
+ module_path="../box2d"
}
subprojects
{
iwgl
yaml
+ box2d
}
includepath
{
./source/Main
./source/Model
}
files
{
[Main]
(source/Main)
Main.cpp
Main.h
Quads.cpp
Quads.h
Desktop.cpp
Desktop.h
IO.cpp
IO.h
[Model]
(source/Model)
Bricks.cpp
Bricks.h
Ball.cpp
Ball.h
Board.cpp
Board.h
}
assets
{
(data)
level.json
}
… и пытаемся все это скомпилировать, попутно внося в Box2D косметические исправления из разряда «сделаем компилятор счастливым»:
Collisionb2BroadPhase.h
- for (int32 i = 0; i < m_moveCount; ++i)
+ for (int32 j = 0; j < m_moveCount; ++j)
{
- m_queryProxyId = m_moveBuffer[i];
+ m_queryProxyId = m_moveBuffer[j];
...
}
...
while (i < m_pairCount)
{
...
}
Commonb2Math.h
/// A 2D column vector.
struct b2Vec2
{
/// Default constructor does nothing (for performance).
- b2Vec2() {}
+ b2Vec2(): x(0.0f), y(0.0f) {}
/// Construct using coordinates.
b2Vec2(float32 x, float32 y) : x(x), y(y) {}
...
float32 x, y;
};
Если после этого вы получаете ошибку связывания:
.PNG "Маленький отважный арканоид (часть 3 — Box2D)")
… то это, скорее всего означает, что вам также как и мне, нравится MSVS 2003. GCC, при этом, собирает проект без ошибок, но нам, конечно, хотелось бы иметь возможность запускать его и под отладчиком тоже. Как бы там ни было, от MSVS 2003 придется отказаться. В принципе, достаточно переключиться на MSVS 2005, но я сразу поставил MSVS 2010, благо она была под рукой. Само переключение осуществляется при помощи Marmalade Configuration Utility.
-2.PNG "Маленький отважный арканоид (часть 3 — Box2D)")
Ну что-же, пора браться за дело. Если в первой статье мы имели дело с «миром иллюзий», во втором с «миром идей», то теперь пришла пора создать «реальный мир», который у нас будет отвечать за физические взаимодействия объектов. Добавим новые файлы в проект:
arcanoid.mkb
#!/usr/bin/env mkb
options
{
module_path="../yaml"
module_path="../box2d"
}
subprojects
{
iwgl
yaml
box2d
}
includepath
{
./source/Main
./source/Model
}
files
{
[Main]
(source/Main)
Main.cpp
Main.h
Quads.cpp
Quads.h
Desktop.cpp
Desktop.h
IO.cpp
IO.h
+ World.cpp
+ World.h
[Model]
(source/Model)
Bricks.cpp
Bricks.h
Ball.cpp
Ball.h
Board.cpp
Board.h
+ IBox2DItem.h
}
assets
{
(data)
level.json
}
Интерфейс IBox2DItem будет отвечать за передачу событий из Box2D в нашу модель данных. Для наших целей, пока достаточно всего двух методов:
IBox2DItem.h
#ifndef _I_BOX2D_ITEM_H_
#define _I_BOX2D_ITEM_H_
#include <Box2D.h>
class IBox2DItem {
public:
virtual void setXY(int X, int Y) {}
virtual bool impact(b2Body* b) {return false;}
};
#endif // _I_BOX2D_ITEM_H_
Да, я знаю, что интерфейс должен содержать только абстрактные методы (первоначально так оно и было), но потом оказалось более удобным иметь некоторую реализацию «по умолчанию», а переименовывать класс было лень. В любом случае, этот вопрос не имеет принципиального значения в контексте нашей статьи.
Метод setXY позволит нам передавать изменения координат движущихся объектов (для того, чтобы эти изменения можно было отобразить на экране), а метод impact позволит нам отслеживать соударения объектов, чуть позже.
World.h
#ifndef _WORLD_H_
#define _WORLD_H_
#include <vector>
#include <Box2D.h>
#include "Desktop.h"
#include "IBox2DItem.h"
const int HALF_MARGIN = 10;
const int V_ITERATIONS = 10;
const int P_ITERATIONS = 10;
const float FRICTION = 0.0f;
const float RESTITUTION = 1.0f;
const float DYN_DENSITY = 0.0f;
const float R_INVIS = 0.0f;
const float EPS = 1.0f;
const float SPEED_SQ = 10.0f;
using namespace std;
class World {
private:
bool isStarted;
int HandleX, HandleH, HandleW;
uint64 timestamp;
int width, height;
b2World* wp;
b2Body* ground;
b2Body* ball;
b2Body* handle;
b2Body* createBox(int x, int y, int hw, int hh, IBox2DItem* userData = NULL);
float32 getTimeStep();
void start();
public:
World(): width(0), height(0), wp(NULL) {}
void init();
void release();
void update();
void refresh();
b2Body* addBrick(int x, int y, int hw, int hh, IBox2DItem* userData) {return createBox(x, y, hw, hh, userData);}
b2Body* addBall(int x, int y, int r, IBox2DItem* userData);
b2Body* addHandle(int x, int y, int hw, int hh, IBox2DItem* userData);
void moveHandle(int x, int y);
typedef vector<b2Body*>::iterator BIter;
};
extern World world;
#endif // _WORLD_H_
Для этого модуля, рассмотрим реализацию подробнее:
World.cpp
#include "s3e.h"
#include "World.h"
#include "Ball.h"
World world;
void World::init() {
isStarted = false;
width = desktop.getWidth();
height = desktop.getHeight();
b2Vec2 gravity(0.0f, 0.0f);
wp = new b2World(gravity);
ground = createBox(width/2, -HALF_MARGIN, width/2, HALF_MARGIN);
createBox(-HALF_MARGIN, height/2, HALF_MARGIN, height/2);
createBox(width/2, height + HALF_MARGIN, width/2, HALF_MARGIN);
createBox(width + HALF_MARGIN, height/2, HALF_MARGIN, height/2);
ball = NULL;
handle = NULL;
}
void World::release() {
if (wp != NULL) {
delete wp;
wp = NULL;
ball = NULL;
handle = NULL;
}
}
...
Методы init и release занимаются корректным созданием и уничтожением основных объектов «мира». Обращаю внимание, что гравитацию мы выставляем в 0 (у нас будет невесовмость), а игровое поле окружаем четырьмя «стенами» (одну из них потом можно будет легко убрать).
Далее определяем методы для создания игровых объектов:
World.cpp
...
b2Body* World::createBox(int x, int y, int hw, int hh, IBox2DItem* userData) {
b2BodyDef def;
def.type = b2_staticBody;
def.position.Set(x, y);
b2Body* r = wp->CreateBody(&def);
b2PolygonShape box;
box.SetAsBox(hw, hh);
b2FixtureDef fd;
fd.shape = &box;
fd.density = 0;
fd.friction = FRICTION;
fd.restitution = RESTITUTION;
r->CreateFixture(&fd);
r->SetUserData(userData);
return r;
}
b2Body* World::addBall(int x, int y, int r, IBox2DItem* userData) {
if (ball != NULL) {
wp->DestroyBody(ball);
}
b2BodyDef def;
def.type = b2_dynamicBody;
def.linearDamping = 0.0f;
def.angularDamping = 0.0f;
def.position.Set(x, y);
ball = wp->CreateBody(&def);
b2CircleShape shape;
shape.m_p.SetZero();
shape.m_radius = r + R_INVIS;
b2FixtureDef fd;
fd.shape = &shape;
fd.density = DYN_DENSITY;
fd.friction = FRICTION;
fd.restitution = RESTITUTION;
ball->CreateFixture(&fd);
ball->SetBullet(true);
ball->SetUserData(userData);
return ball;
}
...
Здесь мы создаем прямоугольный объект (стена или кирпич) и шарик. Кроме формы они отличаются типом. Кирпичи являются статическими (неподвижными) объектами, а шарик динамическим. Box2D требует разделять игровые объекты на два этих типа, из соображений производительности. Также, мы задаем такие физические свойства объектов как упругость, коэффициент трения и т.п. Для удобства, они определены константами в h-файле.
В нашем случае, моделируются абсолютно упругие соударения (RESTITUTION = 1), при отсутствии трения (FRICTION = 0). Также в ноль выставляем параметры linearDamping и angularDamping, отвечающие за торможение движущегося объекта «средой». Первоначально, была идея выставить ненулевое значение FRICTION, чтобы была возможность «подкручивать» шарик ракеткой, но от нее пришлось отказаться. При установке FRICTION в любое ненулевое значение, движение шарика очень быстро вырождается в чистое движение по вертикали или горизонтали.
В userData для body и fixture можно хранить любой указатель. Мы будем хранить там указатель на интерфейс IBox2DItem соответствующих объектов в нашей модели.
World.cpp
...
float32 World::getTimeStep() {
uint64 t = s3eTimerGetMs();
int r = (int)(t - timestamp);
timestamp = t;
return (float32)r / 1000.0f;
}
void World::start() {
if (ball != NULL) {
ball->ApplyLinearImpulse(ball->GetWorldVector(b2Vec2(-10.0f, -10.0f)),
ball->GetWorldPoint(b2Vec2(0.0f, 0.0f)));
}
}
void World::update() {
if (!isStarted) {
isStarted = true;
start();
timestamp = s3eTimerGetMs();
srand((unsigned int)timestamp);
} else {
float32 timeStep = getTimeStep();
wp->Step(timeStep, V_ITERATIONS, P_ITERATIONS);
}
}
void World::refresh() {
if (ball != NULL) {
b2Vec2 pos = ball->GetPosition();
Ball* b = (Ball*)ball->GetUserData();
if (b != NULL) {
b->setXY(pos.x, pos.y);
}
}
}
В методе update мы рассчитываем очередную итерацию существования «мира» методом Step, в который передается три аргумента. Первый аргумент — интервал времени на который производится рассчет. В руководстве пользователя Box2D рекомендуется использовать интервал ~1/60 секунды. Также, настоятельно рекомендуется чтобы он был константным. Следующие два параметра определяют количество итераций при выполнении расчетов и напрямую влияют на качество моделирования. Я передаю в оба параметра значение 10.
При первом вызове метода update, мы придаем шарику начальную скорость. Поскольку все соударения идеально упруги, скорость движения шарика после соударений не уменьшается и однократного задания начальной скорости нам вполне достаточно. При необходимости, мы можем скорректировать скорость между вызовами метода update (ни в коем случае не следует выполнять каких либо манипуляций с объектами в контексте вызова b2World.Step, это, скорее всего, приведет к немедленному разрушению памяти).
Задачей метода refresh является получение измененных координат шарика (после очередного шага расчетов) и передача измененных координат интерфейсу IBox2DItem.
Внесем необходимые изменения в модель:
Bricks.h
#ifndef _BRICKS_H_
#define _BRICKS_H_
#include "IwGL.h"
#include "s3e.h"
#include "Desktop.h"
+#include "World.h"
+#include "IBox2DItem.h"
#define BRICK_COLOR_1 0xffffff00
#define BRICK_COLOR_2 0xff50ff00
#define BRICK_HALF_WIDTH 20
#define BRICK_HALF_HEIGHT 10
#include <vector>
using namespace std;
-class Bricks {
+class Bricks: public IBox2DItem {
private:
struct SBrick {
SBrick(int x, int y): x(x),
y(y),
+ body(NULL),
+ isBroken(false),
hw(BRICK_HALF_WIDTH),
hh(BRICK_HALF_HEIGHT),
ic(BRICK_COLOR_1),
oc(BRICK_COLOR_2) {}
SBrick(const SBrick& p): x(p.x),
y(p.y),
+ body(p.body),
+ isBroken(p.isBroken),
hw(p.hw),
hh(p.hh),
ic(p.ic),
oc(p.oc) {}
int x, y, hw, hh, ic, oc;
+ int isBroken;
+ b2Body* body;
};
vector<SBrick> bricks;
public:
Bricks(): bricks() {}
+ void init() {}
+ void release() {}
void refresh();
void clear(){bricks.clear();}
void add(SBrick& b);
typedef vector<SBrick>::iterator BIter;
friend class Board;
};
#endif // _BRICKS_H_
Bricks.cpp
#include "Bricks.h"
#include "Quads.h"
void Bricks::refresh() {
for (BIter p = bricks.begin(); p != bricks.end(); ++p) {
+ if (p->isBroken) continue;
CIwGLPoint point(p->x, p->y);
point = IwGLTransform(point);
int16* quadPoints = quads.getQuadPoints();
uint32* quadCols = quads.getQuadCols();
if ((quadPoints == NULL) || (quadCols == NULL)) break;
*quadPoints++ = point.x - p->hw;
*quadPoints++ = point.y + p->hh;
*quadCols++ = p->ic;
*quadPoints++ = point.x + p->hw;
*quadPoints++ = point.y + p->hh;
*quadCols++ = p->oc;
*quadPoints++ = point.x + p->hw;
*quadPoints++ = point.y - p->hh;
*quadCols++ = p->ic;
*quadPoints++ = point.x - p->hw;
*quadPoints++ = point.y - p->hh;
*quadCols++ = p->oc;
}
}
void Bricks::add(SBrick& b) {
+ b.body = world.addBrick(b.x, b.y, b.hw, b.hh, (IBox2DItem*)this);
bricks.push_back(b);
}
Ball.h
#ifndef _BALL_H_
#define _BALL_H_
#include <vector>
#include "IwGL.h"
#include "s3e.h"
#include "Desktop.h"
+#include "World.h"
+#include "IBox2DItem.h"
#define MAX_SEGMENTS 7
#define BALL_COLOR_1 0x00000000
#define BALL_COLOR_2 0xffffffff
#define BALL_RADIUS 15
using namespace std;
-class Ball {
+class Ball: public IBox2DItem {
private:
struct Offset {
Offset(int dx, int dy): dx(dx), dy(dy) {}
Offset(const Offset& p): dx(p.dx), dy(p.dy) {}
int dx, dy;
};
vector<Offset> offsets;
int x;
int y;
+ b2Body* body;
public:
void init();
void release() {}
void refresh();
virtual void setXY(int X, int Y);
typedef vector<Offset>::iterator OIter;
};
#endif // _BALL_H_
Ball.cpp
#include "Ball.h"
#include "Quads.h"
#include "Desktop.h"
#include <math.h>
#define PI 3.14159265f
void Ball::init(){
x = desktop.getWidth() / 2;
y = desktop.getHeight()/ 2;
float delta = PI / (float)MAX_SEGMENTS;
float angle = delta / 2.0f;
float r = (float)desktop.toRSize(BALL_RADIUS);
for (int i = 0; i < MAX_SEGMENTS; i++) {
offsets.push_back(Offset((int16)(cos(angle) * r), (int16)(sin(angle) * r)));
angle = angle + delta;
offsets.push_back(Offset((int16)(cos(angle) * r), (int16)(sin(angle) * r)));
angle = angle + delta;
offsets.push_back(Offset((int16)(cos(angle) * r), (int16)(sin(angle) * r)));
}
+ body = world.addBall(x, y, (int)r, (IBox2DItem*)this);
}
void Ball::setXY(int X, int Y) {
x = X;
y = Y;
}
void Ball::refresh() {
CIwGLPoint point(x, y);
point = IwGLTransform(point);
OIter o = offsets.begin();
int r = desktop.toRSize(BALL_RADIUS);
for (int i = 0; i < MAX_SEGMENTS; i++) {
int16* quadPoints = quads.getQuadPoints();
uint32* quadCols = quads.getQuadCols();
if ((quadPoints == NULL) || (quadCols == NULL)) break;
*quadPoints++ = point.x + (r / 4);
*quadPoints++ = point.y + (r / 4);
*quadCols++ = BALL_COLOR_2;
*quadPoints++ = point.x + o->dx;
*quadPoints++ = point.y + o->dy;
*quadCols++ = BALL_COLOR_1;
o++;
*quadPoints++ = point.x + o->dx;
*quadPoints++ = point.y + o->dy;
*quadCols++ = BALL_COLOR_1;
o++;
*quadPoints++ = point.x + o->dx;
*quadPoints++ = point.y + o->dy;
*quadCols++ = BALL_COLOR_1;
o++;
}
}
Здесь все изменения очевидны. Далее вносим изменения в Main:
Main.cpp
#include "Main.h"
#include "s3e.h"
#include "IwGL.h"
#include "Desktop.h"
+#include "World.h"
#include "IO.h"
#include "Quads.h"
#include "Board.h"
Board board;
void init() {
desktop.init();
io.init();
quads.init();
+ world.init();
board.init();
}
void release() {
+ world.release();
io.release();
desktop.release();
}
int main() {
init(); {
while (!s3eDeviceCheckQuitRequest()) {
io.update();
if (io.isKeyDown(s3eKeyAbsBSK) || io.isKeyDown(s3eKeyBack)) break;
+ world.update();
quads.update();
desktop.update();
board.update();
board.refresh();
+ world.refresh();
quads.refresh();
io.refresh();
desktop.refresh();
}
}
release();
return 0;
}
Теперь программу можно запустить на выполнение. Что мы видим? Шарик движется, но как-то очень медленно. Отскоков после соударений не наблюдается. Манипуляции с начальной скоростью не изменяют видимой скорости движения шарика. Все это говорит о том, что мы что-то делаем не так.
Подумаем, что бы это могло быть? Мы задаем все размеры в масштабе экранных координат. Для себя, я обычно считаю, единицу измерения в Box2D равной 1 метру. Даже при разрешении экрана 320x480, получается, что мы пытаемся смоделировать арканоид каких-то совершенно невообразимо эпических размеров (более того, моделируемая физика будет зависеть от размеров экрана устройства, а это уже совсем никуда не годится). Кроме того, Box2D не очень хорошо производит рассчеты с объектами таких размеров. Обычно, рекомендуемые размеры мира не должны превышать десятков метров. Внесем коррективы:
World.h
#ifndef _WORLD_H_
#define _WORLD_H_
#include <vector>
#include <Box2D.h>
#include "Desktop.h"
#include "IBox2DItem.h"
+const float W_WIDTH = 10.0f;
const int HALF_MARGIN = 10;
const int V_ITERATIONS = 10;
const int P_ITERATIONS = 10;
const float FRICTION = 0.0f;
const float RESTITUTION = 1.0f;
const float DYN_DENSITY = 0.0f;
const float R_INVIS = 0.0f;
const float EPS = 1.0f;
const float SPEED_SQ = 10.0f;
using namespace std;
class World {
private:
bool isStarted;
int HandleX, HandleH, HandleW;
uint64 timestamp;
int width, height;
b2World* wp;
b2Body* ground;
b2Body* ball;
b2Body* handle;
b2Body* createBox(int x, int y, int hw, int hh, IBox2DItem* userData = NULL);
float32 getTimeStep();
void start();
+ float toWorld(int x);
+ int fromWorld(float x);
public:
World(): width(0), height(0), wp(NULL) {}
void init();
void release();
void update();
void refresh();
b2Body* addBrick(int x, int y, int hw, int hh, IBox2DItem* userData) {return createBox(x, y, hw, hh, userData);}
b2Body* addBall(int x, int y, int r, IBox2DItem* userData);
typedef vector<b2Body*>::iterator BIter;
};
extern World world;
#endif // _WORLD_H_
World.cpp
#include "s3e.h"
#include "World.h"
#include "Ball.h"
World world;
void World::init() {
isStarted = false;
width = desktop.getWidth();
height = desktop.getHeight();
b2Vec2 gravity(0.0f, 0.0f);
wp = new b2World(gravity);
ground = createBox(width/2, -HALF_MARGIN, width/2, HALF_MARGIN);
createBox(-HALF_MARGIN, height/2, HALF_MARGIN, height/2);
createBox(width/2, height + HALF_MARGIN, width/2, HALF_MARGIN);
createBox(width + HALF_MARGIN, height/2, HALF_MARGIN, height/2);
ball = NULL;
handle = NULL;
}
void World::release() {
if (wp != NULL) {
delete wp;
wp = NULL;
ball = NULL;
handle = NULL;
}
}
+float World::toWorld(int x) {
+ return ((float)x * W_WIDTH) / (float)desktop.getWidth();
+}
+int World::fromWorld(float x) {
+ return (int)((x * (float)desktop.getWidth()) / W_WIDTH);
+}
b2Body* World::createBox(int x, int y, int hw, int hh, IBox2DItem* userData) {
b2BodyDef def;
def.type = b2_staticBody;
- def.position.Set(x, y);
+ def.position.Set(toWorld(x), toWorld(y));
b2Body* r = wp->CreateBody(&def);
b2PolygonShape box;
- box.SetAsBox(hw, hh);
+ box.SetAsBox(toWorld(hw), toWorld(hh));
b2FixtureDef fd;
fd.shape = &box;
fd.density = 0;
fd.friction = FRICTION;
fd.restitution = RESTITUTION;
r->CreateFixture(&fd);
r->SetUserData(userData);
return r;
}
b2Body* World::addBall(int x, int y, int r, IBox2DItem* userData) {
if (ball != NULL) {
wp->DestroyBody(ball);
}
b2BodyDef def;
def.type = b2_dynamicBody;
def.linearDamping = 0.0f;
def.angularDamping = 0.0f;
- def.position.Set(x, y);
+ def.position.Set(toWorld(x), toWorld(y));
ball = wp->CreateBody(&def);
b2CircleShape shape;
shape.m_p.SetZero();
- shape.m_radius = r + R_INVIS;
+ shape.m_radius = toWorld(r) + R_INVIS;
b2FixtureDef fd;
fd.shape = &shape;
fd.density = DYN_DENSITY;
fd.friction = FRICTION;
fd.restitution = RESTITUTION;
ball->CreateFixture(&fd);
ball->SetBullet(true);
ball->SetUserData(userData);
return ball;
}
float32 World::getTimeStep() {
uint64 t = s3eTimerGetMs();
int r = (int)(t - timestamp);
timestamp = t;
return (float32)r / 1000.0f;
}
void World::start() {
if (ball != NULL) {
ball->ApplyLinearImpulse(ball->GetWorldVector(b2Vec2(-10.0f, -10.0f)),
ball->GetWorldPoint(b2Vec2(0.0f, 0.0f)));
}
}
void World::update() {
if (!isStarted) {
isStarted = true;
start();
timestamp = s3eTimerGetMs();
srand((unsigned int)timestamp);
} else {
float32 timeStep = getTimeStep();
wp->Step(timeStep, V_ITERATIONS, P_ITERATIONS);
}
}
void World::refresh() {
if (ball != NULL) {
b2Vec2 pos = ball->GetPosition();
Ball* b = (Ball*)ball->GetUserData();
if (b != NULL) {
- b->setXY(pos.x, pos.y);
+ b->setXY(fromWorld(pos.x), fromWorld(pos.y));
}
}
}
Теперь, независимо от размеров экрана, «ширина» нашего мира будет составлять 10 (метров). Запускаем и убеждаемся, что шарик начал летать с нормальной скоростью и отскакивать от стен. Теперь, добьемся того, чтобы «кирпичи» исчезали после столкновения с ними шарика.
Bricks.h
#ifndef _BRICKS_H_
#define _BRICKS_H_
#include "IwGL.h"
#include "s3e.h"
#include "Desktop.h"
#include "World.h"
#include "IBox2DItem.h"
#define BRICK_COLOR_1 0xffffff00
#define BRICK_COLOR_2 0xff50ff00
#define BRICK_HALF_WIDTH 20
#define BRICK_HALF_HEIGHT 10
#include <vector>
using namespace std;
class Bricks: public IBox2DItem {
private:
struct SBrick {
SBrick(int x, int y): x(x),
y(y),
body(NULL),
isBroken(false),
hw(BRICK_HALF_WIDTH),
hh(BRICK_HALF_HEIGHT),
ic(BRICK_COLOR_1),
oc(BRICK_COLOR_2) {}
SBrick(const SBrick& p): x(p.x),
y(p.y),
body(p.body),
isBroken(p.isBroken),
hw(p.hw),
hh(p.hh),
ic(p.ic),
oc(p.oc) {}
int x, y, hw, hh, ic, oc;
int isBroken;
b2Body* body;
};
vector<SBrick> bricks;
+ virtual bool impact(b2Body* b);
public:
Bricks(): bricks() {}
void init() {}
void release() {}
void refresh();
void clear(){bricks.clear();}
void add(SBrick& b);
typedef vector<SBrick>::iterator BIter;
friend class Board;
};
#endif // _BRICKS_H_
Bricks.cpp
#include "Bricks.h"
#include "Quads.h"
void Bricks::refresh() {
for (BIter p = bricks.begin(); p != bricks.end(); ++p) {
if (p->isBroken) continue;
CIwGLPoint point(p->x, p->y);
point = IwGLTransform(point);
int16* quadPoints = quads.getQuadPoints();
uint32* quadCols = quads.getQuadCols();
if ((quadPoints == NULL) || (quadCols == NULL)) break;
*quadPoints++ = point.x - p->hw;
*quadPoints++ = point.y + p->hh;
*quadCols++ = p->ic;
*quadPoints++ = point.x + p->hw;
*quadPoints++ = point.y + p->hh;
*quadCols++ = p->oc;
*quadPoints++ = point.x + p->hw;
*quadPoints++ = point.y - p->hh;
*quadCols++ = p->ic;
*quadPoints++ = point.x - p->hw;
*quadPoints++ = point.y - p->hh;
*quadCols++ = p->oc;
}
}
+bool Bricks::impact(b2Body* b) {
+ for (BIter p = bricks.begin(); p != bricks.end(); ++p) {
+ if (p->body == b) {
+ p->isBroken = true;
+ return true;
+ }
+ }
+ return false;
+}
void Bricks::add(SBrick& b) {
b.body = world.addBrick(b.x, b.y, b.hw, b.hh, (IBox2DItem*)this);
bricks.push_back(b);
}
World.h
#ifndef _WORLD_H_
#define _WORLD_H_
#include <vector>
#include <Box2D.h>
#include "Desktop.h"
#include "IBox2DItem.h"
const float W_WIDTH = 10.0f;
const int HALF_MARGIN = 10;
const int V_ITERATIONS = 10;
const int P_ITERATIONS = 10;
const float FRICTION = 0.0f;
const float RESTITUTION = 1.0f;
const float DYN_DENSITY = 0.0f;
const float R_INVIS = 0.0f;
const float EPS = 1.0f;
const float SPEED_SQ = 10.0f;
using namespace std;
-class World {
+class World: public b2ContactListener {
private:
bool isStarted;
int HandleX, HandleH, HandleW;
uint64 timestamp;
int width, height;
b2World* wp;
b2Body* ground;
b2Body* ball;
b2Body* handle;
b2Body* createBox(int x, int y, int hw, int hh, IBox2DItem* userData = NULL);
float32 getTimeStep();
+ vector<b2Body*>* broken;
void start();
+ void impact(b2Body* b);
+ virtual void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse);
float toWorld(int x);
int fromWorld(float x);
public:
World(): broken(), width(0), height(0), wp(NULL) {}
void init();
void release();
void update();
void refresh();
b2Body* addBrick(int x, int y, int hw, int hh, IBox2DItem* userData) {
return createBox(x, y, hw, hh, userData);
}
b2Body* addBall(int x, int y, int r, IBox2DItem* userData);
+ typedef vector<b2Body*>::iterator BIter;
};
extern World world;
#endif // _WORLD_H_
World.cpp
#include "s3e.h"
#include "World.h"
#include "Ball.h"
World world;
void World::init() {
+ broken = new vector<b2Body*>();
isStarted = false;
width = desktop.getWidth();
height = desktop.getHeight();
b2Vec2 gravity(0.0f, 0.0f);
wp = new b2World(gravity);
+ wp->SetContactListener(this);
ground = createBox(width/2, -HALF_MARGIN, width/2, HALF_MARGIN);
createBox(-HALF_MARGIN, height/2, HALF_MARGIN, height/2);
createBox(width/2, height + HALF_MARGIN, width/2, HALF_MARGIN);
createBox(width + HALF_MARGIN, height/2, HALF_MARGIN, height/2);
ball = NULL;
handle = NULL;
}
void World::release() {
if (wp != NULL) {
delete wp;
wp = NULL;
ball = NULL;
handle = NULL;
}
+ delete broken;
}
float World::toWorld(int x) {
return ((float)x * W_WIDTH) / (float)desktop.getWidth();
}
int World::fromWorld(float x) {
return (int)((x * (float)desktop.getWidth()) / W_WIDTH);
}
b2Body* World::createBox(int x, int y, int hw, int hh, IBox2DItem* userData) {
b2BodyDef def;
def.type = b2_staticBody;
def.position.Set(toWorld(x), toWorld(y));
b2Body* r = wp->CreateBody(&def);
b2PolygonShape box;
box.SetAsBox(toWorld(hw), toWorld(hh));
b2FixtureDef fd;
fd.shape = &box;
fd.density = 0;
fd.friction = FRICTION;
fd.restitution = RESTITUTION;
r->CreateFixture(&fd);
r->SetUserData(userData);
return r;
}
b2Body* World::addBall(int x, int y, int r, IBox2DItem* userData) {
if (ball != NULL) {
wp->DestroyBody(ball);
}
b2BodyDef def;
def.type = b2_dynamicBody;
def.linearDamping = 0.0f;
def.angularDamping = 0.0f;
def.position.Set(toWorld(x), toWorld(y));
ball = wp->CreateBody(&def);
b2CircleShape shape;
shape.m_p.SetZero();
shape.m_radius = toWorld(r) + R_INVIS;
b2FixtureDef fd;
fd.shape = &shape;
fd.density = DYN_DENSITY;
fd.friction = FRICTION;
fd.restitution = RESTITUTION;
ball->CreateFixture(&fd);
ball->SetBullet(true);
ball->SetUserData(userData);
return ball;
}
float32 World::getTimeStep() {
uint64 t = s3eTimerGetMs();
int r = (int)(t - timestamp);
timestamp = t;
return (float32)r / 1000.0f;
}
void World::start() {
if (ball != NULL) {
ball->ApplyLinearImpulse(ball->GetWorldVector(b2Vec2(-10.0f, -10.0f)),
ball->GetWorldPoint(b2Vec2(0.0f, 0.0f)));
}
}
+void World::impact(b2Body* b) {
+ IBox2DItem* it = (IBox2DItem*)b->GetUserData();
+ if (it != NULL) {
+ if (it->impact(b)) {
+ for (BIter p = broken->begin(); p != broken->end(); ++p) {
+ if (*p == b) return;
+ }
+ broken->push_back(b);
+ }
+ }
+}
+void World::PostSolve(b2Contact* contact, const b2ContactImpulse* impulse) {
+ impact(contact->GetFixtureA()->GetBody());
+ impact(contact->GetFixtureB()->GetBody());
+}
void World::update() {
if (!isStarted) {
isStarted = true;
start();
timestamp = s3eTimerGetMs();
srand((unsigned int)timestamp);
} else {
float32 timeStep = getTimeStep();
wp->Step(timeStep, V_ITERATIONS, P_ITERATIONS);
}
}
void World::refresh() {
+ for (BIter p = broken->begin(); p != broken->end(); ++p) {
+ wp->DestroyBody(*p);
+ }
+ broken->clear();
if (ball != NULL) {
b2Vec2 pos = ball->GetPosition();
Ball* b = (Ball*)ball->GetUserData();
if (b != NULL) {
b->setXY(fromWorld(pos.x), fromWorld(pos.y));
}
}
}
Здесь, как я уже говорил выше, важно не пытаться удалить объект при рассчете очередной итерации b2World.Step (именно это и произойдет если попытаться удалить объект непосредственно в PostSolve). Также, не следует рассчитывать на то, что PostSolve будет вызыван однократно. Вполне возможна ситуация когда он сработает, например, дважды для одного «кирпича». Если мы внесем объект в broken без предварительной проверки, мы попытаемся разрушить его дважды, что неизбежно приведет к разрушению памяти. Поскольку в broken не может накопиться большого количества объектов, линейный поиск объекта в векторе нас вполне устраивает по производительности.
Осталось совсем немного. Добавим ракетку. Первоначально, я хотел сделать ракетку динамическим объектом, ограничив ее движение по вертикали при помощи PrismaticJoint. Перемещать ее по горизонтали, можно было-бы временно создавая MouseJoint. Но потом, я решил, что надо быть проще.
Дело в том, что решение сделать ракетку динамическим объектом не очень удачно. Box2D придется все время отслеживать столкновение динамических объектов, а задача эта настолько сложная, что даже Box2D не очень хорошо с ней справляется. Установка SetBullet помогает, но возможны случаи когда шарик будет пролетать сквозь ракетку, что, естественно, совершенно недопустимо, в нашем случае. Поэтому, ракетка будет статическим объектом. Мы просто будем уничтожать ее между шагами расчета и создавать в новом месте, при необходимости. Помимо прочего, этот способ гораздо проще в реализации.
Внесем в проект необходимые изменения:
arcanoid.mkb
#!/usr/bin/env mkb
options
{
module_path="../yaml"
module_path="../box2d"
}
subprojects
{
iwgl
yaml
box2d
}
includepath
{
./source/Main
./source/Model
}
files
{
[Main]
(source/Main)
Main.cpp
Main.h
Quads.cpp
Quads.h
Desktop.cpp
Desktop.h
IO.cpp
IO.h
+ TouchPad.cpp
+ TouchPad.h
[Model]
(source/Model)
Bricks.cpp
Bricks.h
Ball.cpp
Ball.h
Board.cpp
Board.h
+ Handle.cpp
+ Handle.h
}
assets
{
(data)
level.json
}
Немного измененный модуль TouchPad возьмем отсюда:
TouchPad.h
#ifndef _TOUCHPAD_H_
#define _TOUCHPAD_H_
#include "s3ePointer.h"
#include "Desktop.h"
#define MAX_TOUCHES 3
enum EMessageType {
emtNothing = 0x00,
emtTouchEvent = 0x10,
emtTouchIdMask = 0x03,
emtTouchMask = 0x78,
emtMultiTouch = 0x14,
emtTouchOut = 0x18,
emtTouchDown = 0x30,
emtTouchUp = 0x50,
emtTouchOutUp = 0x58,
emtTouchMove = 0x70,
emtSingleTouchDown = 0x30,
emtSingleTouchUp = 0x50,
emtSingleTouchMove = 0x70,
emtMultiTouchDown = 0x34,
emtMultiTouchUp = 0x54,
emtMultiTouchMove = 0x74
};
struct Touch {
int x, y;
bool isActive, isPressed, isMoved;
int id;
};
class TouchPad {
private:
bool IsAvailable;
bool IsMultiTouch;
Touch Touches[MAX_TOUCHES];
Touch* findTouch(int id);
static void HandleMultiTouchButton(s3ePointerTouchEvent* event);
static void HandleMultiTouchMotion(s3ePointerTouchMotionEvent* event);
public:
static bool isTouchDown(int eventCode);
static bool isTouchUp(int eventCode);
bool isAvailable() const { return IsAvailable; }
bool isMultiTouch() const { return IsMultiTouch; }
Touch* getTouchByID(int id);
Touch* getTouch(int index) { return &Touches[index]; }
Touch* getTouchPressed();
int getTouchCount() const;
bool init();
void release();
void update();
void clear();
};
extern TouchPad touchPad;
#endif // _TOUCHPAD_H_
TouchPad.cpp
#include "TouchPad.h"
TouchPad touchPad;
bool TouchPad::isTouchDown(int eventCode) {
return (eventCode & emtTouchMask) == emtTouchDown;
}
bool TouchPad::isTouchUp(int eventCode) {
return (eventCode & emtTouchMask) == emtTouchUp;
}
void TouchPad::HandleMultiTouchButton(s3ePointerTouchEvent* event) {
Touch* touch = touchPad.findTouch(event->m_TouchID);
if (touch != NULL) {
touch->isPressed = event->m_Pressed != 0;
touch->isActive = true;
touch->x = event->m_x;
touch->y = event->m_y;
touch->id = event->m_TouchID;
}
}
void TouchPad::HandleMultiTouchMotion(s3ePointerTouchMotionEvent* event) {
Touch* touch = touchPad.findTouch(event->m_TouchID);
if (touch != NULL) {
if (touch->isActive) {
touch->isMoved = true;
}
touch->isActive = true;
touch->x = event->m_x;
touch->y = event->m_y;
}
}
void HandleSingleTouchButton(s3ePointerEvent* event) {
Touch* touch = touchPad.getTouch(0);
touch->isPressed = event->m_Pressed != 0;
touch->isActive = true;
touch->x = event->m_x;
touch->y = event->m_y;
touch->id = 0;
}
void HandleSingleTouchMotion(s3ePointerMotionEvent* event) {
Touch* touch = touchPad.getTouch(0);
if (touch->isActive) {
touch->isMoved = true;
}
touch->isActive = true;
touch->x = event->m_x;
touch->y = event->m_y;
}
Touch* TouchPad::getTouchByID(int id) {
for (int i = 0; i < MAX_TOUCHES; i++) {
if (Touches[i].isActive && Touches[i].id == id)
return &Touches[i];
}
return NULL;
}
Touch* TouchPad::getTouchPressed() {
for (int i = 0; i < MAX_TOUCHES; i++) {
if (Touches[i].isPressed && Touches[i].isActive)
return &Touches[i];
}
return NULL;
}
Touch* TouchPad::findTouch(int id) {
if (!IsAvailable)
return NULL;
for (int i = 0; i < MAX_TOUCHES; i++) {
if (Touches[i].id == id)
return &Touches[i];
}
for (int i = 0; i < MAX_TOUCHES; i++) {
if (!Touches[i].isActive) {
Touches[i].id = id;
return &Touches[i];
}
}
return NULL;
}
int TouchPad::getTouchCount() const {
if (!IsAvailable)
return 0;
int r = 0;
for (int i = 0; i < MAX_TOUCHES; i++) {
if (Touches[i].isActive) {
r++;
}
}
return r;
}
void TouchPad::update() {
for (int i = 0; i < MAX_TOUCHES; i++) {
Touches[i].isMoved = false;
}
if (IsAvailable) {
s3ePointerUpdate();
}
}
void TouchPad::clear() {
for (int i = 0; i < MAX_TOUCHES; i++) {
if (!Touches[i].isPressed) {
Touches[i].isActive = false;
}
Touches[i].isMoved = false;
}
}
bool TouchPad::init() {
IsAvailable = s3ePointerGetInt(S3E_POINTER_AVAILABLE) ? true : false;
if (!IsAvailable) return false;
for (int i = 0; i < MAX_TOUCHES; i++) {
Touches[i].isPressed = false;
Touches[i].isActive = false;
Touches[i].isMoved = false;
Touches[i].id = 0;
}
IsMultiTouch = s3ePointerGetInt(S3E_POINTER_MULTI_TOUCH_AVAILABLE) ? true : false;
if (IsMultiTouch) {
s3ePointerRegister(S3E_POINTER_TOUCH_EVENT,
(s3eCallback)HandleMultiTouchButton, NULL);
s3ePointerRegister(S3E_POINTER_TOUCH_MOTION_EVENT,
(s3eCallback)HandleMultiTouchMotion, NULL);
} else {
s3ePointerRegister(S3E_POINTER_BUTTON_EVENT,
(s3eCallback)HandleSingleTouchButton, NULL);
s3ePointerRegister(S3E_POINTER_MOTION_EVENT,
(s3eCallback)HandleSingleTouchMotion, NULL);
}
return true;
}
void TouchPad::release() {
if (IsAvailable) {
if (IsMultiTouch) {
s3ePointerUnRegister(S3E_POINTER_TOUCH_EVENT,
(s3eCallback)HandleMultiTouchButton);
s3ePointerUnRegister(S3E_POINTER_TOUCH_MOTION_EVENT,
(s3eCallback)HandleMultiTouchMotion);
} else {
s3ePointerUnRegister(S3E_POINTER_BUTTON_EVENT,
(s3eCallback)HandleSingleTouchButton);
s3ePointerUnRegister(S3E_POINTER_MOTION_EVENT,
(s3eCallback)HandleSingleTouchMotion);
}
}
}
IO.h
#ifndef _IO_H_
#define _IO_H_
#include "TouchPad.h"
class IO {
private:
bool KeysAvailable;
public:
void init();
void release();
void update();
void refresh();
bool isKeyDown(s3eKey key) const;
};
extern IO io;
#endif // _IO_H_
IO.cpp
#include "s3e.h"
#include "IO.h"
IO io;
void IO::init() {
touchPad.init();
}
void IO::release() {
touchPad.release();
}
void IO::update() {
touchPad.update();
s3eKeyboardUpdate();
}
void IO::refresh() {
touchPad.clear();
}
bool IO::isKeyDown(s3eKey key) const {
return (s3eKeyboardGetState(key) & S3E_KEY_STATE_DOWN) == S3E_KEY_STATE_DOWN;
}
Теперь, добавим модуль Handle:
Handle.h
#ifndef _HANDLE_H_
#define _HANDLE_H_
#include "IwGL.h"
#include "s3e.h"
#include "Desktop.h"
#include "World.h"
#include "IBox2DItem.h"
#define HANDLE_COLOR 0xffff3000
#define HANDLE_H_WIDTH 40
#define HANDLE_H_HEIGHT 10
#define HANDLE_H_POS 50
class Handle: public IBox2DItem {
private:
int x;
int y;
int touchId;
public:
void init();
void release() {}
void refresh();
void update();
virtual void setXY(int X, int Y);
};
#endif // _HANDLE_H_
Handle.cpp
#include "Handle.h"
#include "Quads.h"
#include "TouchPad.h"
void Handle::init() {
x = desktop.getWidth() / 2;
y = desktop.getHeight();
touchId = -1;
}
void Handle::setXY(int X, int Y) {
x = X;
y = Y;
}
void Handle::refresh() {
CIwGLPoint point(x, y);
point = IwGLTransform(point);
int16* quadPoints = quads.getQuadPoints();
uint32* quadCols = quads.getQuadCols();
if ((quadPoints == NULL) || (quadCols == NULL)) return;
*quadPoints++ = point.x - desktop.toRSize(HANDLE_H_WIDTH);
*quadPoints++ = point.y + desktop.toRSize(HANDLE_H_HEIGHT);
*quadCols++ = HANDLE_COLOR;
*quadPoints++ = point.x + desktop.toRSize(HANDLE_H_WIDTH);
*quadPoints++ = point.y + desktop.toRSize(HANDLE_H_HEIGHT);
*quadCols++ = HANDLE_COLOR;
*quadPoints++ = point.x + desktop.toRSize(HANDLE_H_WIDTH);
*quadPoints++ = point.y - desktop.toRSize(HANDLE_H_HEIGHT);
*quadCols++ = HANDLE_COLOR;
*quadPoints++ = point.x - desktop.toRSize(HANDLE_H_WIDTH);
*quadPoints++ = point.y - desktop.toRSize(HANDLE_H_HEIGHT);
*quadCols++ = HANDLE_COLOR;
world.addHandle(x, y, desktop.toRSize(HANDLE_H_WIDTH), desktop.toRSize(HANDLE_H_HEIGHT), (IBox2DItem*)this);
}
void Handle::update() {
Touch* t = NULL;
if (touchId > 0) {
t = touchPad.getTouchByID(touchId);
} else {
t = touchPad.getTouchPressed();
}
if (t != NULL) {
touchId = t->id;
world.moveHandle(t->x, t->y);
} else {
touchId = -1;
}
}
И внесем изменения в World и Board:
World.h
#ifndef _WORLD_H_
#define _WORLD_H_
#include <vector>
#include <Box2D.h>
#include "Desktop.h"
#include "IBox2DItem.h"
const float W_WIDTH = 10.0f;
const int HALF_MARGIN = 10;
const int V_ITERATIONS = 10;
const int P_ITERATIONS = 10;
const float FRICTION = 0.0f;
const float RESTITUTION = 1.0f;
const float DYN_DENSITY = 0.0f;
const float R_INVIS = 0.0f;
const float EPS = 1.0f;
const float SPEED_SQ = 10.0f;
using namespace std;
class World: public b2ContactListener {
private:
bool isStarted;
+ bool isHandleCreated;
int HandleX, HandleH, HandleW;
uint64 timestamp;
int width, height;
b2World* wp;
b2Body* ground;
b2Body* ball;
b2Body* handle;
b2Body* createBox(int x, int y, int hw, int hh, IBox2DItem* userData = NULL);
float32 getTimeStep();
vector<b2Body*>* broken;
void start();
void impact(b2Body* b);
virtual void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse);
float toWorld(int x);
int fromWorld(float x);
public:
World(): broken(), width(0), height(0), wp(NULL) {}
void init();
void release();
void update();
void refresh();
b2Body* addBrick(int x, int y, int hw, int hh, IBox2DItem* userData) {return createBox(x, y, hw, hh, userData);}
b2Body* addBall(int x, int y, int r, IBox2DItem* userData);
+ b2Body* addHandle(int x, int y, int hw, int hh, IBox2DItem* userData);
+ void moveHandle(int x, int y);
typedef vector<b2Body*>::iterator BIter;
};
extern World world;
#endif // _WORLD_H_
World.cpp
#include "s3e.h"
#include "World.h"
#include "Ball.h"
World world;
void World::init() {
broken = new vector<b2Body*>();
isStarted = false;
width = desktop.getWidth();
height = desktop.getHeight();
b2Vec2 gravity(0.0f, 0.0f);
wp = new b2World(gravity);
wp->SetContactListener(this);
ground = createBox(width/2, -HALF_MARGIN, width/2, HALF_MARGIN);
createBox(-HALF_MARGIN, height/2, HALF_MARGIN, height/2);
createBox(width/2, height + HALF_MARGIN, width/2, HALF_MARGIN);
createBox(width + HALF_MARGIN, height/2, HALF_MARGIN, height/2);
ball = NULL;
handle = NULL;
}
void World::release() {
if (wp != NULL) {
delete wp;
wp = NULL;
ball = NULL;
handle = NULL;
}
delete broken;
}
float World::toWorld(int x) {
return ((float)x * W_WIDTH) / (float)desktop.getWidth();
}
int World::fromWorld(float x) {
return (int)((x * (float)desktop.getWidth()) / W_WIDTH);
}
b2Body* World::createBox(int x, int y, int hw, int hh, IBox2DItem* userData) {
b2BodyDef def;
def.type = b2_staticBody;
def.position.Set(toWorld(x), toWorld(y));
b2Body* r = wp->CreateBody(&def);
b2PolygonShape box;
box.SetAsBox(toWorld(hw), toWorld(hh));
b2FixtureDef fd;
fd.shape = &box;
fd.density = 0;
fd.friction = FRICTION;
fd.restitution = RESTITUTION;
r->CreateFixture(&fd);
r->SetUserData(userData);
return r;
}
b2Body* World::addBall(int x, int y, int r, IBox2DItem* userData) {
if (ball != NULL) {
wp->DestroyBody(ball);
}
b2BodyDef def;
def.type = b2_dynamicBody;
def.linearDamping = 0.0f;
def.angularDamping = 0.0f;
def.position.Set(toWorld(x), toWorld(y));
ball = wp->CreateBody(&def);
b2CircleShape shape;
shape.m_p.SetZero();
shape.m_radius = toWorld(r) + R_INVIS;
b2FixtureDef fd;
fd.shape = &shape;
fd.density = DYN_DENSITY;
fd.friction = FRICTION;
fd.restitution = RESTITUTION;
ball->CreateFixture(&fd);
ball->SetBullet(true);
ball->SetUserData(userData);
return ball;
}
+b2Body* World::addHandle(int x, int y, int hw, int hh, IBox2DItem* userData) {
+ HandleW = hw; HandleH = hh;
+ if (handle != NULL) {
+ wp->DestroyBody(handle);
+ }
+ b2BodyDef def;
+ def.type = b2_staticBody;
+ def.position.Set(toWorld(x), toWorld(y));
+ handle = wp->CreateBody(&def);
+ b2PolygonShape box;
+ box.SetAsBox(toWorld(hw), toWorld(hh));
+ b2FixtureDef fd;
+ fd.shape = &box;
+ fd.density = DYN_DENSITY;
+ fd.friction = FRICTION;
+ fd.restitution = RESTITUTION;
+ handle->CreateFixture(&fd);
+ handle->SetUserData(userData);
+ return handle;
+}
+void World::moveHandle(int x, int y) {
+ isHandleCreated = true;
+ HandleX = x;
+}
float32 World::getTimeStep() {
uint64 t = s3eTimerGetMs();
int r = (int)(t - timestamp);
timestamp = t;
return (float32)r / 1000.0f;
}
void World::start() {
if (ball != NULL) {
ball->ApplyLinearImpulse(ball->GetWorldVector(b2Vec2(-10.0f, -10.0f)),
ball->GetWorldPoint(b2Vec2(0.0f, 0.0f)));
}
}
void World::impact(b2Body* b) {
IBox2DItem* it = (IBox2DItem*)b->GetUserData();
if (it != NULL) {
if (it->impact(b)) {
for (BIter p = broken->begin(); p != broken->end(); ++p) {
if (*p == b) return;
}
broken->push_back(b);
}
}
}
void World::PostSolve(b2Contact* contact, const b2ContactImpulse* impulse) {
impact(contact->GetFixtureA()->GetBody());
impact(contact->GetFixtureB()->GetBody());
}
void World::update() {
if (!isStarted) {
isStarted = true;
start();
timestamp = s3eTimerGetMs();
srand((unsigned int)timestamp);
} else {
float32 timeStep = getTimeStep();
wp->Step(timeStep, V_ITERATIONS, P_ITERATIONS);
}
}
void World::refresh() {
for (BIter p = broken->begin(); p != broken->end(); ++p) {
wp->DestroyBody(*p);
}
broken->clear();
+ if (isHandleCreated) {
+ if (handle != NULL) {
+ int y = fromWorld(handle->GetPosition().y);
+ IBox2DItem* data = (IBox2DItem*)handle->GetUserData();
+ if (HandleX < HandleW) {
+ HandleX = HandleW;
+ }
+ if (HandleX > desktop.getWidth() - HandleW) {
+ HandleX = desktop.getWidth() - HandleW;
+ }
+ handle = addHandle(HandleX, y, HandleW, HandleH, data);
+ b2Vec2 pos = handle->GetPosition();
+ data->setXY(fromWorld(pos.x), fromWorld(pos.y));
+ }
+ }
if (ball != NULL) {
b2Vec2 pos = ball->GetPosition();
Ball* b = (Ball*)ball->GetUserData();
if (b != NULL) {
b->setXY(fromWorld(pos.x), fromWorld(pos.y));
}
}
}
Board.h
#ifndef _BOARD_H_
#define _BOARD_H_
#include <yaml.h>
#include <vector>
#include <String>
#include "Bricks.h"
#include "Ball.h"
+#include "Handle.h"
#define MAX_NAME_SZ 100
using namespace std;
enum EBrickMask {
ebmX = 0x01,
ebmY = 0x02,
ebmComplete = 0x03,
ebmWidth = 0x04,
ebmHeight = 0x08,
ebmIColor = 0x10,
ebmOColor = 0x20
};
class Board {
private:
struct Type {
Type(const char* s, const char* n, const char* v): s(s), n(n), v(v) {}
Type(const Type& p): s(p.s), n(p.n), v(p.v) {}
string s, n, v;
};
Bricks bricks;
Ball ball;
+ Handle handle;
yaml_parser_t parser;
yaml_event_t event;
vector<string> scopes;
vector<Type> types;
char currName[MAX_NAME_SZ];
int brickMask;
int brickX, brickY, brickW, brickH, brickIC, brickOC;
bool isTypeScope;
void load();
void clear();
void notify();
const char* getScopeName();
void setProperty(const char* scope, const char* name, const char* value);
void closeTag(const char* scope);
int fromNum(const char* s);
public:
Board(): scopes(), types() {}
void init();
void release();
void refresh();
void update();
typedef vector<string>::iterator SIter;
typedef vector<Type>::iterator TIter;
};
#endif // _BOARD_H_
Board.cpp
#include "Board.h"
#include "Desktop.h"
const char* BOARD_SCOPE = "board";
const char* LEVEL_SCOPE = "level";
const char* TYPE_SCOPE = "types";
const char* TYPE_PROPERTY = "type";
const char* WIDTH_PROPERTY = "width";
const char* HEIGHT_PROPERTY = "height";
const char* IC_PROPERTY = "inner_color";
const char* OC_PROPERTY = "outer_color";
const char* X_PROPERTY = "x";
const char* Y_PROPERTY = "y";
void Board::init() {
ball.init();
bricks.init();
+ handle.init();
load();
}
void Board::release() {
+ handle.release();
bricks.release();
ball.release();
}
...
void Board::refresh() {
bricks.refresh();
ball.refresh();
+ handle.refresh();
}
+void Board::update() {
+ handle.update();
+}
На этом все. Теперь, у нас есть работающий прототип игры Arcanoid, который можно собрать как для Android, так и под iPhone.
Автор: GlukKazan
