void Level::loadExit(MvUint tileX, MvUint tileY)
{
LOGME_CALL("Level::loadExit");
LOGME_DEBUG("Exit at %d, %d", tileX, tileY);
auto e = mEcsContext.e();
auto c = mEcsContext.c();
EngineContext& ctx = mEngineContext;
MvAnimation::Ptr aSpawn(new MvAnimation(RepeatMode::Loop));
for (int i = 0; i < 3; ++i) {
StaticDrawable::Ptr ptr(new StaticDrawable(ctx, Tex::Blob, BlueSpawn[i]));
aSpawn->addDrawable(std::move(ptr));
aSpawn->addFrame(i, sf::milliseconds(240));
}
Entity eSpawn = createEntity();
CrawlComponents& cSpawn = c->attach<Transform, Renderable, Sensor>(eSpawn);
Renderable* cRenderable = cSpawn.get<Renderable>();
Sensor* cSensor = cSpawn.get<Sensor>();
Transform* cTransform = cSpawn.get<Transform>();
cRenderable->setLayer(def::layer::BackgroundNear);
cRenderable->setDrawable(std::move(aSpawn));
cTransform->setPosition(tileX * TW, tileY * TH);
cSensor->setShapeCircle(2.f, sf::Vector2f(tileX * TW, tileY * TH));
cSensor->setCollisionCategory(Collision::World);
cSensor->setCollisionWith(Collision::Player);
cSensor->setCategory(Category::ExitSensor);
mEcsContext.s()->get<PhysicsSystem>()->initialize(eSpawn);
}
void Level::receive(const BulletSpawn &entity)
{
LOGME_CALL("Level::receive<BulletSpawn>");
Transform* cTransform = mEcsContext.c()->get(entity.spawner).get<Transform>();
LOGME_ASSERT(nullptr != cTransform, "Transform component is required");
sf::Vector2f pos = cTransform->getPosition();
const int bulletNum = 12;
for (int i = 0; i < bulletNum; ++i)
{
float fi = i * 2 * M_PI / bulletNum;
Entity e = createEntity();
CrawlComponents& d = mEcsContext.c()->attach<Transform, RigidBody, Renderable, Kinematic>(e);
Kinematic* cKinematic = d.get<Kinematic>();
Renderable* cRenderable = d.get<Renderable>();
RigidBody* cRigidBody = d.get<RigidBody>();
Transform* cTransform = d.get<Transform>();
sf::Vector2f v(1.0f * cos(fi), 1.0f * sin(fi));
cKinematic->setLinearVelocity(120.f * v);
cTransform->setPosition(pos);
StaticDrawable::Ptr dBullet(new StaticDrawable(mEngineContext, Tex::Blob,
sf::IntRect(14 * 16, 16, 5, 4)));
cRenderable->setDrawable(std::move(dBullet));
cRigidBody->setBodyDynamic();
cRigidBody->setBulletMode(true);
cRigidBody->setCollisionCategory(Collision::Bullet);
cRigidBody->setCollisionWith(Collision::Player);
cRigidBody->setCollisionWith(Collision::World);
cRigidBody->setShapeBox(5, 4);
mEcsContext.s()->get<PhysicsSystem>()->initialize(e);
}
}
void Level::loadLevel(MvId level)
{
LOGME_CALL("Level::loadLevel");
LOGME_INFO("Loading level %d", level);
reset();
// loadWorldBounds();
// Level image is 4x4
const MvUint col = level % 4;
const MvUint row = level / 4;
const MvUint x0 = col * WorldTileWidth;
const MvUint y0 = row * WorldTileHeight;
const MvUint W = WorldTileWidth;
const MvUint H = WorldTileHeight;
for (MvUint j = 0; j < H; ++j) {
for (MvUint i = 0; i < W; ++i) {
handleColor(i, j, mData.getPixel(x0 + i, y0 + j));
}
}
auto c = mEcsContext.c();
Entity world = createEntity();
CrawlComponents& cWorld = c->attach<Renderable>(world);
Renderable* cRenderable = cWorld.get<Renderable>();
MvDrawable* tilemap = mTileMap.get();
tilemap->setPosition(-8, -8);
cRenderable->setDrawable(std::move(mTileMap));
cRenderable->setLayer(def::layer::BackgroundNear);
LOGME_INFO("Level loaded. Created entities: %d, to destroy: %d",
mCreatedEntities.size(), mDeadEntities.size());
}
void Level::loadPlayerSpawner(MvUint tileX, MvUint tileY)
{
LOGME_CALL("Level::loadPlayerSpawner");
LOGME_DEBUG("Player at %d, %d", tileX, tileY);
auto c = mEcsContext.c();
EngineContext& ctx = mEngineContext;
MvAnimation::Ptr aSpawn(new MvAnimation(RepeatMode::Loop));
{
for (int i = 0; i < 3; ++i) {
StaticDrawable::Ptr ptr(new StaticDrawable(ctx, Tex::Blob, GreenSpawn[i]));
aSpawn->addDrawable(std::move(ptr));
aSpawn->addFrame(i, sf::milliseconds(240));
}
mve::Entity eSpawn = createEntity();
CrawlComponents& cSpawn = c->attach<Transform, Renderable>(eSpawn);
Renderable* cRenderable = cSpawn.get<Renderable>();
Transform* cTransform = cSpawn.get<Transform>();
cRenderable->setLayer(def::layer::BackgroundNear);
cRenderable->setDrawable(std::move(aSpawn));
cTransform->setPosition(tileX * TW, tileY * TH - 6);
}
// Initialize the player
DirectionalDrawable::Ptr dPlayer(new DirectionalDrawable);
for (std::size_t i = 0; i < Direction::Count; ++i) {
MvAnimation::Ptr aIdle(new MvAnimation(RepeatMode::Loop));
MvAnimation::Ptr aMove(new MvAnimation(RepeatMode::Loop));
StaticDrawable::Ptr ptr;
for (std::size_t j = 0; j < AnimIdleSize; ++j) {
ptr.reset(new StaticDrawable(ctx, Tex::Blob, PlayerIdle[i * AnimIdleSize + j]));
aIdle->addDrawable(std::move(ptr));
aIdle->addFrame(j, AnimIdleSpeed);
}
for (std::size_t j = 0; j < AnimMoveSize; ++j) {
ptr.reset(new StaticDrawable(ctx, Tex::Blob, PlayerMove[i * AnimMoveSize + j]));
aMove->addDrawable(std::move(ptr));
aMove->addFrame(j, AnimMoveSpeed);
}
dPlayer->setDrawable(CharState::Idle, i, std::move(aIdle));
dPlayer->setDrawable(CharState::Move, i, std::move(aMove));
}
mPlayerEntity = createEntity();
CrawlComponents& cPlayer = c->attach<Transform, Kinematic, Renderable, State,
RigidBody, Attributes>(mPlayerEntity);
Attributes* cAttributes = cPlayer.get<Attributes>();
Kinematic* cKinematic = cPlayer.get<Kinematic>();
Renderable* cRenderable = cPlayer.get<Renderable>();
RigidBody* cRigidBody = cPlayer.get<RigidBody>();
State* cState = cPlayer.get<State>();
Transform* cTransform = cPlayer.get<Transform>();
cAttributes->baseSpeed = 150.0f; // px/s
cKinematic->setDirection(Direction::Down);
cRenderable->setDrawable(std::move(dPlayer), DrawableType::Directional);
cRenderable->setLayer(def::layer::ForegroundMiddle);
cRigidBody->disableRotation();
cRigidBody->setBodyDynamic();
cRigidBody->setCollisionCategory(Collision::Player);
cRigidBody->setCollisionWith(Collision::Bullet);
cRigidBody->setCollisionWith(Collision::Enemy);
cRigidBody->setCollisionWith(Collision::World);
cRigidBody->setShapeBox(10, 10, sf::Vector2f(0, 1));
cState->setState(CharState::Idle);
cTransform->setPosition(tileX * TW, tileY * TH);
mPhysics->initialize(mPlayerEntity);
}
void Level::loadEnemySpawner(MvUint tileX, MvUint tileY, MvUint feature)
{
LOGME_CALL("Level::loadEnemySpawner");
LOGME_DEBUG("Spawning enemy at %d, %d", tileX * TW, tileY * TH);
auto e = mEcsContext.e();
auto c = mEcsContext.c();
EngineContext& ctx = mEngineContext;
sf::Time frames[] = {
sf::milliseconds(3600 + randOf(-480, 480)),
sf::milliseconds(1200),
sf::milliseconds(120),
sf::milliseconds(1200)
};
MvAnimation::Ptr dEnemy(new MvAnimation(RepeatMode::Loop));
StaticDrawable::Ptr ptr;
ptr.reset(new StaticDrawable(ctx, Tex::Blob, EnemyFrames[1]));
dEnemy->addDrawable(std::move(ptr));
ptr.reset(new StaticDrawable(ctx, Tex::Blob, EnemyFrames[0]));
dEnemy->addDrawable(std::move(ptr));
dEnemy->addFrame(0, frames[0]);
dEnemy->addFrame(1, frames[1]);
dEnemy->addFrame(0, frames[2]);
dEnemy->addFrame(1, frames[3]);
Entity enemy = createEntity();
CrawlComponents& cEnemy = c->attach<Attributes, Behavior, Renderable,
RigidBody, Sensor, Transform>(enemy);
Attributes* cAttributes = cEnemy.get<Attributes>();
Behavior* cBehavior = cEnemy.get<Behavior>();
Renderable* cRenderable = cEnemy.get<Renderable>();
RigidBody* cEnemyBody = cEnemy.get<RigidBody>();
Sensor* cSensor = cEnemy.get<Sensor>();
Transform* cTransform = cEnemy.get<Transform>();
cAttributes->baseSpeed = 50.0f;
cAttributes->visionRange = 50.0f;
if (feature & 0xE0) {
cAttributes->canShootBullets = true;
cAttributes->hasShootBullets = false;
}
// Values working with animation frames
cBehavior->addAction(Behavior::Sleeping, frames[0]);
cBehavior->addAction(Behavior::Gazing, frames[1]);
cBehavior->addAction(Behavior::Sleeping, frames[2]);
cBehavior->addAction(Behavior::Gazing, frames[3]);
cTransform->setPosition(tileX * TW, tileY * TH);
cRenderable->setDrawable(std::move(dEnemy), mve::DrawableType::Default);
cRenderable->setLayer(def::layer::ForegroundMiddle);
cSensor->setCategory(Category::EnemySensor);
cSensor->setCollisionCategory(Collision::Enemy);
cSensor->setCollisionWith(Collision::Player);
cSensor->setShapeCircle(cAttributes->visionRange);
cSensor->setAttachToEntity();
cEnemyBody->enableCollision();
cEnemyBody->disableRotation();
cEnemyBody->setBodyKinematic();
cEnemyBody->setShapeBox(9, 10);
cEnemyBody->setDensity(10.f);
cEnemyBody->setCollisionCategory(Collision::Enemy);
cEnemyBody->setCollisionWith(Collision::Player | Collision::World);
mEcsContext.s()->get<PhysicsSystem>()->initialize(enemy);
}