void TMXMapImporter::buildTiledLayer(Game *game, TiledLayerInfo *tli, int idOffset)
{
TiledLayer *tiledLayerToAdd = new TiledLayer( tli->width,
tli->height,
tli->tileSetInfo->tilewidth,
tli->tileSetInfo->tileheight,
0,
tli->collidable,
largestLayerWidth,
largestLayerHeight);
game->getGSM()->getWorld()->addLayer(tiledLayerToAdd);
// WE HAVE TO ADD ALL THE TILES
int uncollidableIndex = tli->tileSetInfo->firstgid;
for (unsigned int i = 0; i < tli->gids.size(); i++)
{
Tile *tileToAdd = new Tile();
tileToAdd->textureID = tli->gids[i] + idOffset - 1;
if (tli->gids[i] == uncollidableIndex)
tileToAdd->collidable = false;
else
tileToAdd->collidable = tli->collidable;
tiledLayerToAdd->addTile(tileToAdd);
}
}
void TMXMapImporter::buildImageLayer(Game *game, ImageLayerInfo *ili, int idOffset)
{
TiledLayer *imageLayerToAdd = new TiledLayer( 1,
1,
ili->imagewidth,
ili->imageheight,
0,
ili->collidable,
largestLayerWidth,
largestLayerHeight);
game->getGSM()->getWorld()->addLayer(imageLayerToAdd);
TextureManager *textureManager = game->getGraphics()->getWorldTextureManager();
Tile *imageTile = new Tile();
imageTile->collidable = ili->collidable;
wstring imageSourceW(ili->imageSource.begin(), ili->imageSource.end());
imageTile->textureID = textureManager->loadTexture(dir + imageSourceW) + idOffset - 1;
imageLayerToAdd->addTile(imageTile);
}
void World::initBox2DTiles()
{
//Don't have any gravity, because we're top-down
b2Vec2 gravity(0.0f, 0.0f);
boxWorld = new b2World(gravity);
for(unsigned int i = 0; i < layers->size(); i++)
{
if(layers->at(i)->hasCollidableTiles() == true)
{
TiledLayer* layer = (TiledLayer*)layers->at(i);
int columns = layer->getColumns();
int rows = layer->getRows();
for(int j = 0; j < rows; j++)
{
for(int z = 0; z < columns; z++)
{
Tile* tile = layer->getTile(j,z);
if(tile->collidable == true)
{
b2BodyDef tileBodyDef;
float tileWidth = (layer->getTileWidth() * 1.0f)/5.0f;
float tileHeight = (layer->getTileHeight() * 1.0f)/5.0f;
float pX = (z)*tileWidth + tileWidth/2.0f;
float pY = -1.0f*(j)*tileHeight - (tileHeight/2.0f);
tileBodyDef.position.Set(pX, pY);
b2Body* tileBody = boxWorld->CreateBody(&tileBodyDef);
b2PolygonShape tileBox;
tileBox.SetAsBox(tileWidth/2.0f, tileHeight/2.0f);
tileBody->CreateFixture(&tileBox, 0.0f);
}
}
}
}
}
}
bool TMXMapImporter::buildWorldFromInfo(Game *game)
{
TextureManager *worldTextureManager = game->getGraphics()->getWorldTextureManager();
if (mapType == MapType::ORTHOGONAL_MAP)
{
World *world = game->getGSM()->getWorld();
int largestLayerWidth = 0;
int largestLayerHeight = 0;
// LET'S FIRST FIGURE OUT THE WORLD WIDTH AND HEIGHT
// FIRST THE IMAGE LAYERS
map<string, ImageLayerInfo>::const_iterator iliIt = imageLayerInfos.begin();
while (iliIt != imageLayerInfos.end())
{
string key = iliIt->first;
ImageLayerInfo ili = imageLayerInfos[key];
if (ili.imagewidth > largestLayerWidth)
largestLayerWidth = ili.imagewidth;
if (ili.imageheight > largestLayerHeight)
largestLayerHeight = ili.imageheight;
iliIt++;
}
// AND THE TILED LAYERS
map<string, TiledLayerInfo>::const_iterator tliIt = tiledLayerInfos.begin();
while (tliIt != tiledLayerInfos.end())
{
string key = tliIt->first;
TiledLayerInfo tli = tiledLayerInfos[key];
int layerWidth = tli.width * tli.tileSetInfo->tilewidth;
if (layerWidth > largestLayerWidth)
largestLayerWidth = layerWidth;
int layerHeight = tli.height * tli.tileSetInfo->tileheight;
if (layerHeight > largestLayerHeight)
largestLayerHeight = layerHeight;
tliIt++;
}
unsigned int idOffset = worldTextureManager->getWStringTable()->getNumWStringsInTable();
// FIRST LOAD ALL THE TILE SETS
map<string, TileSetInfo>::const_iterator tsiIt = tileSetInfos.begin();
while (tsiIt != tileSetInfos.end())
{
string key = tsiIt->first;
TileSetInfo tsi = tileSetInfos[key];
wstring sourceImageW(tsi.sourceImage.begin(), tsi.sourceImage.end());
bool success = worldTextureManager->loadTileSetFromTexture(game, dir, sourceImageW, tsi.tilewidth, tsi.tileheight);
if (!success) return false;
tsiIt++;
}
// NOW LOAD THE IMAGE LAYERS, IF THERE ARE ANY
iliIt = imageLayerInfos.begin();
while (iliIt != imageLayerInfos.end())
{
string key = iliIt->first;
ImageLayerInfo ili = imageLayerInfos[key];
TiledLayer *imageLayerToAdd = new TiledLayer( 1,
1,
ili.imagewidth,
ili.imageheight,
0,
ili.collidable,
largestLayerWidth,
largestLayerHeight);
world->addLayer(imageLayerToAdd);
Tile *imageTile = new Tile();
imageTile->collidable = ili.collidable;
wstring imageSourceW(ili.imageSource.begin(), ili.imageSource.end());
imageTile->textureID = worldTextureManager->loadTexture(dir + imageSourceW);
imageLayerToAdd->addTile(imageTile);
iliIt++;
}
// AND NOW LOAD THE TILED LAYERS, WHICH REFERENCE THE TILE SETS
tliIt = tiledLayerInfos.begin();
while (tliIt != tiledLayerInfos.end())
{
// @TODO WE'LL NEED TO CUSTOMIZE THIS
bool collidableLayer = false;
string key = tliIt->first;
TiledLayerInfo tli = tiledLayerInfos[key];
TiledLayer *tiledLayerToAdd = new TiledLayer( tli.width,
tli.height,
tli.tileSetInfo->tilewidth,
tli.tileSetInfo->tileheight,
0,
tli.collidable,
largestLayerWidth,
largestLayerHeight);
world->addLayer(tiledLayerToAdd);
// WE HAVE TO ADD ALL THE TILES
int row = 0;
int col = 0;
int uncollidableIndex = tli.tileSetInfo->firstgid;
for (unsigned int i = 0; i < tli.gids.size(); i++)
{
Tile *tileToAdd = new Tile();
tileToAdd->textureID = tli.gids[i] + idOffset - 1;
if (tli.gids[i] == uncollidableIndex)
tileToAdd->collidable = false;
else {
tileToAdd->collidable = tli.collidable;
}
tiledLayerToAdd->addTile(tileToAdd);
}
tliIt++;
}
// AND MAKE THE WORLD DIMENSIONS THE
// SIZE OF THE LARGEST LAYER
world->setWorldWidth(largestLayerWidth);
world->setWorldHeight(largestLayerHeight);
}
return true;
}
void TiledObject::initialize()
{
if(!m_componentCompleted) {
m_componentCompleted = true;
return;
}
// Extract properties from layer
TiledLayer *tiledLayer = qobject_cast<TiledLayer *>(parent());
if(!tiledLayer && !tiledLayer->layer())
return;
if(!tiledLayer->layer()->isObjectLayer())
return;
m_layerName = tiledLayer->name();
if(m_objectGroup)
m_objectGroup->deleteLater();
m_objectGroup = new TMXObjectGroup(*tiledLayer->layer(), this);
if(!m_objectGroup)
return;
int collisions = 0;
m_collisionIndex = -1;
foreach(const TMXMapObject &object, m_objectGroup->objects())
{
if(object.name() == m_name && object.type() == m_type)
{
if(!static_cast<TiledScene *>(tiledLayer->parentItem()))
return;
//if(!collisions) {
setProperties(object.properties());
setX(object.x());
setY(object.y());
setWidth(object.width());
setHeight(object.height());
setRotation(object.rotation());
setVisible(object.isVisible());
setId(object.id());
//}
CollisionItem *item = new CollisionItem(tiledLayer->parentItem());
item->setX(object.x());
item->setY(object.y());
item->setWidth(object.width());
item->setHeight(object.height());
item->setRotation(object.rotation());
item->setVisible(object.isVisible());
item->setId(object.id());
item->setProperties(object.properties());
item->setCollisionIndex(collisions);
m_collisionItems.append(item);
switch(object.shape())
{
case TMXMapObject::Rectangle:
createRectangularFixture(object, item);
break;
case TMXMapObject::Ellipse:
createEllipseFixture(object, item);
break;
case TMXMapObject::Polygon:
createPolygonFixture(object, item);
break;
case TMXMapObject::Polyline:
createPolylineFixture(object, item);
break;
default:
qWarning() << "Unhandled object group: " << object.name();
break;
}
setBody(item->body());
collisions++;
}
}
}
