Пример #1
0
bool MGMap::mouseScrollingUpdate(int x, int y)
{
	if(m_MouseScrollingOngoing)
	{
		int setY = getScrollY() + m_MouseScrollingYClick - y;
		int setX = getScrollX() + m_MouseScrollingXClick - x;

		if(setY > getTopEdge())
		{
			setY = getTopEdge();
		}
		else if(setY < getWindowHeight() - getHeight() * getTileHeight() - getBottomEdge())
		{
			setY = getWindowHeight() - getHeight() * getTileHeight() - getBottomEdge();
		}

		if(setX > getLeftEdge())
		{
			setX = getLeftEdge();
		}
		else if(setX < getWindowWidth() - getWidth() * getTileWidth() - getRightEdge())
		{
			setX = getWindowWidth() - getWidth() * getTileWidth() - getRightEdge();
		}

		setScrollOffset(setX, setY);
	}
	return m_MouseScrollingOngoing;
}
Пример #2
0
void TiledMap::setColTiles()
{

	int width = getTileWidth();
	int height = getTileHeight();
	int tilesetID(0);
	int tileID(-1);

	for (int y(0); y < static_cast<int>(currentTMXMap_->getLayer()[0]->data.size()); ++y)
	{
		for (int x(0); x < static_cast<int>(currentTMXMap_->getLayer()[0]->data[0].size()); x++)
		{
			tilesetID = getTilesetID(currentTMXMap_->getLayer()[0]->data[y][x]);
			if (tilesetID > -1)
			{
				tileID = currentTMXMap_->getLayer()[0]->data[y][x] - currentTMXMap_->getTileSet()[tilesetID]->firstgid_; // +firstGID_[tilesetID];
				if (currentTMXMap_->getTileSet()[tilesetID]->getTilePropertyName(tileID) == "blocked" && currentTMXMap_->getTileSet()[tilesetID]->getTilePropertyValue(tileID) == "true")
				{
					blocked_[y][x] = 1;
				}
				else
				{
					blocked_[y][x] = 0;
				}
			}
			else
			{
				blocked_[y][x] = 0;
			}
		}

	}
	std::cout << blocked_.size() << " - " << blocked_[0].size() << std::endl;

}
Пример #3
0
void tmx::Tileset::tell() {
	std::cout << "Name: " << getName() << "\n"
			  << "Source: " << getSource() << "\n"
			  << "First gID: " << getFirstGid() << "\n"
			  << "Tile Width: " << getTileWidth() << "\n"
			  << "Tile Height: " << getTileHeight() << "\n"
			  << "Spacing: " << getSpacing() << "\n"
			  << "Margin: " << getMargin() << std::endl;
}
Пример #4
0
ossimRefPtr<ossimImageData> ossimImageSource::getTile(const ossimIpt& origin,
                                                      ossim_uint32 resLevel)
{
   ossimIrect tileRect(origin.x,
                       origin.y,
                       origin.x + getTileWidth()  - 1,
                       origin.y + getTileHeight() - 1);
   
   return getTile(tileRect, resLevel);
}
Пример #5
0
rspfRefPtr<rspfImageData> rspfImageSource::getTile(const rspfIpt& origin,
        rspf_uint32 resLevel)
{
    rspfIrect tileRect(origin.x,
                       origin.y,
                       origin.x + getTileWidth()  - 1,
                       origin.y + getTileHeight() - 1);

    return getTile(tileRect, resLevel);
}
Пример #6
0
int MGMap::getTileIndex(int clickX, int clickY)
{
	MGFLOG_INFO("MGMap::getTileIndex(" << clickX << ", " << clickY << ")");
	if(	clickX > getLeftEdge() &&
		clickX < (getWindowWidth() - getRightEdge()) &&
		clickY > getTopEdge() &&
		clickY < (getWindowHeight() - getBottomEdge()))
	{
		int x = (clickX - getScrollX()) / getTileWidth();
		int y = (clickY - getScrollY()) / getTileHeight();
		if(x < getWidth() && y < getHeight())
		{
			return y * getWidth() + x;
		}
	}
	return -1; // Click outside of map
}
Пример #7
0
void ossimLasReader::initTile()
{
   const ossim_uint32 BANDS = getNumberOfOutputBands();

   m_tile = new ossimImageData(this,
                               getOutputScalarType(),
                               BANDS,
                               getTileWidth(),
                               getTileHeight());

   for(ossim_uint32 band = 0; band < BANDS; ++band)
   {
      m_tile->setMinPix(getMinPixelValue(band),   band);
      m_tile->setMaxPix(getMaxPixelValue(band),   band);
      m_tile->setNullPix(getNullPixelValue(band), band);
   }

   m_tile->initialize();
}
Пример #8
0
void TiledLayer::createBox2DTileWorld(Game *game, b2World *world)
{
	//Definitions for the tile body
	b2PolygonShape boxShape;
	boxShape.SetAsBox(64.0f, 64.0f);
	b2FixtureDef boxFixtureDef;
	boxFixtureDef.shape = &boxShape;
	boxFixtureDef.density = 1.0f;

	b2BodyDef myBodyDef;
	myBodyDef.type = b2_staticBody; //change body type

	if (this->hasCollidableTiles()) // For all the collidable tiles only
	{
		int cols = getColumns();
		int rows = getRows();
		int height = getTileHeight();
		int width = getTileWidth();
		Tile *tile;


		// create a box2d b2Body for each collidable tile
		for (int j = 0; j < cols; j++)
		{
			for (int k = 0; k < rows; k++)
			{
				tile = getTile(k, j);
				if ((*tile).collidable)
				{
					float32 tX = k * width / 64.0f;
					float32 tY = j * height / 64.0f;
					myBodyDef.position.Set(tX / 2, tY / 2);
					b2Body* staticBody = world->CreateBody(&myBodyDef);
					staticBody->CreateFixture(&boxFixtureDef);

				}
			}
		}
	}

}
Пример #9
0
bool TiledMap::initaliseMap()
{
	if (currentTMXMap_)
	{
		mapBounds_.x = static_cast<unsigned> (currentTMXMap_->getWidth());
		mapBounds_.y = static_cast<unsigned> (currentTMXMap_->getHeight());
		tileSize_.x = static_cast<unsigned> (currentTMXMap_->getTileWidth());
		tileSize_.y = static_cast<unsigned> (currentTMXMap_->getTileHeight());

		firstGID_.resize(currentTMXMap_->getTileSet().size());
		tileCount_.resize(currentTMXMap_->getTileSet().size());

		blocked_.resize(mapBounds_.y); //resize the first dimension of the blocked map vector to the map bounds 

		for (int i(0); i < static_cast<int>(blocked_.size()); ++i)//Initialise the 2nd dimension with the right size
			blocked_[i].resize(mapBounds_.x);

		for (int i(0); i < static_cast<int>(firstGID_.size()); ++i)
		{
			firstGID_[i] = currentTMXMap_->getTileSet()[i]->firstgid_;
			tileCount_[i] = currentTMXMap_->getTileSet()[i]->tileCount_;
		}

		tempText.loadFromFile("res//tiles//tilesheet.png");

		initVertexArrays();
		setColTiles();

		for (int i(0); i < 8; ++i)
		{
			collisionArea_[i].collider.width = static_cast<float>(getTileWidth());
			collisionArea_[i].collider.height = static_cast<float>(getTileHeight());
		}

	}
	else
		return(false);

	return(true);
}
Пример #10
0
void
IsoMapTile::render()
{
	SDL_Rect rect;

	if (getImage() == NULL || getScreen() == NULL)
		return;

	int xOff = 0, yOff = 0;

	yOff = -(TILE_HEIGHT / 2);

	if (getLocation().getY() % 2 == 0)
		xOff = -(TILE_WIDTH / 2);

	rect.x = getLocation().getX() * TILE_WIDTH + xOff;
	rect.y = getLocation().getY() * (TILE_HEIGHT / 2) +
	         (TILE_HEIGHT - getTileHeight()) + yOff;
	rect.w = getTileWidth();
	rect.h = getTileHeight();

	SDL_BlitSurface(getImage(), NULL, getScreen(), &rect);
}
Пример #11
0
void tmx::Tilemap::tell() {
    std::cout << "==MAP==" << "\n\n"
              << "Version: " << getVersion() << "\n"
              << "Orientation: " << getOrientation() << "\n"
              << "Width: " << getWidth() << "\n"
              << "Height: " << getHeight() << "\n"
              << "Tile width: " << getTileWidth() << "\n"
              << "Tile height: " << getTileHeight() << "\n"
              << "Background color: " << getBackgroundColor() << "\n"
              << "# of tilesets: " << mTileset.size() << "\n"
              << "# of layers: " << mLayer.size() << "\n"
              << "# of objectgroups: " << mObjectGroup.size() << "\n"
              << "# of imagelayers: " << mImageLayer.size() << "\n\n"
              << "==TILESETS==" << "\n" << std::endl;

    for(std::vector<Tileset>::size_type i = 0; i != mTileset.size(); ++i) {
        mTileset[i].tell();
    }

    std::cout << "\n==LAYERS==\n" << std::endl;

    for(std::vector<Layer>::size_type i = 0; i != mLayer.size(); ++i) {
        mLayer[i].tell();
    }

    std::cout << "\n==OBJECT GROUPS==\n" << std::endl;

    for(std::vector<Objectgroup>::size_type i = 0; i != mObjectGroup.size(); ++i) {
        mObjectGroup[i].tell();
    }

    std::cout << "\n==IMAGE LAYERS==\n" << std::endl;

    for(std::vector<Imagelayer>::size_type i = 0; i != mImageLayer.size(); ++i) {
        mImageLayer[i].tell();
    }
}
Пример #12
0
	bool isSolidAtCoord(const glm::vec2 &pos) {
		return getTile(pos.x / getTileWidth(), pos.y / getTileHeight()).isSolid;
	}
Пример #13
0
	bool isSolidAtCoord(float x, float y) const {
		return getTile(x / getTileWidth(), y / getTileHeight()).isSolid;
	}
Пример #14
0
void TopdownTileSet::mapChunkToTiles(const mc::ChunkPos& chunk,
		std::set<TilePos>& tiles) {
	tiles.insert(TilePos(chunk.x / getTileWidth(), chunk.z / getTileWidth()));
}
Пример #15
0
bool TiledMap::isCollided(sf::FloatRect collider, const sf::Vector2f& moveVector)
{

	/*
	Collision Area order =
	left-up = (-1,-1)
	up = (0,-1)
	right-up = (1,-1)
	right = (1, 0)
	right-down = (1,1)
	down = (0,1)
	left-down = (-1,1)
	left = (-1,0)
	*/
	sf::Vector2i gridLoc(static_cast<int>(collider.left / getTileWidth()), static_cast<int>(collider.top / getTileWidth()));

	collisionArea_[0].blockedValue = blocked_[gridLoc.y - 1][gridLoc.x - 1]; //left-up tile
	collisionArea_[0].collider.top = static_cast<float>((gridLoc.y - 1) * getTileHeight());
	collisionArea_[0].collider.left = static_cast<float>((gridLoc.x - 1) * getTileWidth());

	collisionArea_[1].blockedValue = blocked_[gridLoc.y - 1][gridLoc.x]; //up tile
	collisionArea_[1].collider.top = static_cast<float>((gridLoc.y - 1) * getTileHeight());
	collisionArea_[1].collider.left = static_cast<float>((gridLoc.x) * getTileWidth());

	collisionArea_[2].blockedValue = blocked_[gridLoc.y - 1][gridLoc.x + 1]; //right-up tile
	collisionArea_[2].collider.top = static_cast<float>((gridLoc.y - 1) * getTileHeight());
	collisionArea_[2].collider.left = static_cast<float>((gridLoc.x + 1) * getTileWidth());

	collisionArea_[3].blockedValue = blocked_[gridLoc.y][gridLoc.x + 1]; //right tile
	collisionArea_[3].collider.top = static_cast<float>((gridLoc.y) * getTileHeight());
	collisionArea_[3].collider.left = static_cast<float>((gridLoc.x + 1) * getTileWidth());

	collisionArea_[4].blockedValue = blocked_[gridLoc.y + 1][gridLoc.x + 1]; //right-down tile
	collisionArea_[4].collider.top = static_cast<float>((gridLoc.y + 1) * getTileHeight());
	collisionArea_[4].collider.left = static_cast<float>((gridLoc.x + 1) * getTileWidth());


	collisionArea_[5].blockedValue = blocked_[gridLoc.y + 1][gridLoc.x]; //down tile
	collisionArea_[5].collider.top = static_cast<float>((gridLoc.y + 1) * getTileHeight());
	collisionArea_[5].collider.left = static_cast<float>((gridLoc.x) * getTileWidth());

	collisionArea_[6].blockedValue = blocked_[gridLoc.y + 1][gridLoc.x - 1]; //down-left tile
	collisionArea_[6].collider.top = static_cast<float>((gridLoc.y + 1) * getTileHeight());
	collisionArea_[6].collider.left = static_cast<float>((gridLoc.x - 1) * getTileWidth());

	collisionArea_[7].blockedValue = blocked_[gridLoc.y][gridLoc.x - 1]; //left tile
	collisionArea_[7].collider.top = static_cast<float>((gridLoc.y) * getTileHeight());
	collisionArea_[7].collider.left = static_cast<float>((gridLoc.x - 1) * getTileWidth());

	for (int i(0); i < 8; ++i)
	{
		if (collisionArea_[i].blockedValue == 1)
		{
			if (collisionArea_[i].collider.intersects(sf::FloatRect(collider.left + moveVector.x, collider.top + moveVector.y, collider.width, collider.height)))
				return(true);
		}
	}

	return false;

}
Пример #16
0
sf::Vector2f TiledMap::getCollisionVector(sf::FloatRect collider, const sf::Vector2f& moveVector, const int id)
{
	assert(p_player_);
	sf::Vector2f moveBy(moveVector);

	//Get the grid location of the player
	sf::Vector2i gridLoc(static_cast<int>(collider.left / getTileWidth()), static_cast<int>(collider.top / getTileWidth()));
	/*
	Collision Area order =
	left-up = (-1,-1)
	up = (0,-1)
	right-up = (1,-1)
	right = (1, 0)
	right-down = (1,1)
	down = (0,1)
	left-down = (-1,1)
	left = (-1,0)
	*/
	collisionArea_[0].blockedValue = blocked_[gridLoc.y - 1][gridLoc.x - 1]; //left-up tile
	collisionArea_[0].collider.top = static_cast<float>((gridLoc.y - 1) * getTileHeight());
	collisionArea_[0].collider.left = static_cast<float>((gridLoc.x - 1) * getTileWidth());

	collisionArea_[1].blockedValue = blocked_[gridLoc.y - 1][gridLoc.x]; //up tile
	collisionArea_[1].collider.top = static_cast<float>((gridLoc.y - 1) * getTileHeight());
	collisionArea_[1].collider.left = static_cast<float>((gridLoc.x) * getTileWidth());

	collisionArea_[2].blockedValue = blocked_[gridLoc.y - 1][gridLoc.x + 1]; //right-up tile
	collisionArea_[2].collider.top = static_cast<float>((gridLoc.y - 1) * getTileHeight());
	collisionArea_[2].collider.left = static_cast<float>((gridLoc.x + 1) * getTileWidth());

	collisionArea_[3].blockedValue = blocked_[gridLoc.y][gridLoc.x + 1]; //right tile
	collisionArea_[3].collider.top = static_cast<float>((gridLoc.y) * getTileHeight());
	collisionArea_[3].collider.left = static_cast<float>((gridLoc.x + 1) * getTileWidth());

	collisionArea_[4].blockedValue = blocked_[gridLoc.y + 1][gridLoc.x + 1]; //right-down tile
	collisionArea_[4].collider.top = static_cast<float>((gridLoc.y + 1) * getTileHeight());
	collisionArea_[4].collider.left = static_cast<float>((gridLoc.x + 1) * getTileWidth());


	collisionArea_[5].blockedValue = blocked_[gridLoc.y + 1][gridLoc.x]; //down tile
	collisionArea_[5].collider.top = static_cast<float>((gridLoc.y + 1) * getTileHeight());
	collisionArea_[5].collider.left = static_cast<float>((gridLoc.x) * getTileWidth());

	collisionArea_[6].blockedValue = blocked_[gridLoc.y + 1][gridLoc.x - 1]; //down-left tile
	collisionArea_[6].collider.top = static_cast<float>((gridLoc.y + 1) * getTileHeight());
	collisionArea_[6].collider.left = static_cast<float>((gridLoc.x - 1) * getTileWidth());

	collisionArea_[7].blockedValue = blocked_[gridLoc.y][gridLoc.x - 1]; //left tile
	collisionArea_[7].collider.top = static_cast<float>((gridLoc.y) * getTileHeight());
	collisionArea_[7].collider.left = static_cast<float>((gridLoc.x - 1) * getTileWidth());

	for (int i(0); i < 8; ++i)
	{
		if (collisionArea_[i].blockedValue == 1)
		{
			//if there is a horizontal collision
			if (collisionArea_[i].collider.intersects(sf::FloatRect(collider.left + moveVector.x, collider.top, collider.width, collider.height)))
			{
				moveBy.x = 0.f;
			}
			//if there is a vertical collision
			if (collisionArea_[i].collider.intersects(sf::FloatRect(collider.left, collider.top + moveVector.y, collider.width, collider.height)))
			{
				moveBy.y = 0.f;
			}
		}

	}

	EnemyManager* eManage(EnemyManager::Get());

	assert(eManage != nullptr);

	if (id != 0)
	{

		if (p_player_->getCollider().intersects(sf::FloatRect(collider.left + moveVector.x, collider.top, collider.width, collider.height)))
		{
			moveBy.x = 0.f;
		}

		if (p_player_->getCollider().intersects(sf::FloatRect(collider.left, collider.top + moveVector.y, collider.width, collider.height)))
		{
			moveBy.y = 0.f;
		}

		for (int i(0); i < eManage->getEnemyCount(); ++i)
		{
			Enemy* e(eManage->getEnemy(i));

			assert(e != nullptr); //sanity checks

			if (i + 1 != id)
			{
				if (e->getAlive())
				{
					if (e->getCollider().intersects(sf::FloatRect(collider.left + moveVector.x, collider.top, collider.width, collider.height)))
					{
						e->collidedX_ = true;
						moveBy.x *= -1.f;
						if (e->getCollider().intersects(sf::FloatRect(collider.left + (moveVector.x + moveBy.x), collider.top, collider.width, collider.height)))
						{
							moveBy.x *= -1.f;
						}
					}
					else
					{
						e->collidedX_ = false;
					}
					if (e->getCollider().intersects(sf::FloatRect(collider.left, collider.top + moveVector.y, collider.width, collider.height)))
					{
						e->collidedY_ = true;
						moveBy.y *= -1.f;
						if (e->getCollider().intersects(sf::FloatRect(collider.left, collider.top + (moveVector.y + moveBy.y), collider.width, collider.height)))
						{
							moveBy.y *= -1.f;
						}
					}

					else
					{
						e->collidedY_ = false;
					}
				}
			}
		}
	}
	else
	{
		for (int i(0); i < gconsts::Gameplay::MAXENEMIES; i++)
		{
			Enemy* e(eManage->getEnemy(i));
			if (e->getAlive())
			{
				assert(e != nullptr); //sanity checks

				if (e->getCollider().intersects(sf::FloatRect(collider.left + moveVector.x, collider.top, collider.width, collider.height)))
				{
					moveBy.x = 0.f;
				}
				if (e->getCollider().intersects(sf::FloatRect(collider.left, collider.top + moveVector.y, collider.width, collider.height)))
				{
					moveBy.y = 0.f;
				}
			}
		}
	}

	return(moveBy);
}
Пример #17
0
TileSetGroupID MapSection::getTileSetGroup() const {
	return TileSetGroupID(getWorld(), getRenderView(), getTileWidth());
}
Пример #18
0
TileSetID MapSection::getTileSet(int rotation) const {
	return TileSetID(getWorld(), getRenderView(), getTileWidth(), rotation);
}
Пример #19
0
void SDL_TMXMap::Populate_Map(SDL_Renderer *Render)
{
    if( MapSurf || getMapFile().length())
    {
        if (!MapSurf)
        {
            std::ifstream *in_xml = new ifstream(getMapFile().c_str(), ifstream::in);
            if(!in_xml->is_open())
            {
                std::cout << "No way to Populate Map. Quitting..." <<endl;
                return;
            }
            std::stringstream *ss_xml = new std::stringstream;
            *ss_xml << in_xml->rdbuf();
            char *xml_data = new char[ss_xml->str().length()+1]();
            strcpy(xml_data, ss_xml->str().c_str());
            in_xml->close();
            delete ss_xml;
            Load_Map(xml_data);
            MapSurf = SDL_CreateRGBSurface(0, getWidth()*getTileWidth(), getHeight()*getTileHeight(), 32, rmask, gmask, bmask, amask);
        }

        string ResDir = "Resources\\";
        SDL_Surface **TileSurf = new SDL_Surface*[getNumTilesets()];
        for ( unsigned int fn = 0; fn < getNumTilesets(); fn++)
        {
            //eventually, there will be a means to load multiple images per tileset. TODO: Make a loop that allows it.
            //TODO: Write it so that it also works with
            string Filenname = ResDir + getTileset(fn).getImage(0).getFilename();
            TileSurf[fn] = IMG_Load(Filenname.c_str());
            if (!TileSurf[fn]) return;
        }

        unsigned long color = getTileset(0).getImage(0).getTrans();
        SDL_Color CKey;
        CKey.r = (color & 0xFF0000)   >> 16;
        CKey.g = (color & 0x00FF00)   >> 8 ;
        CKey.b = (color & 0x0000FF)        ;
        SDL_SetColorKey( MapSurf , SDL_TRUE , SDL_MapRGB(TileSurf[0]->format , CKey.r , CKey.g , CKey.b));
        SDL_Rect SrcRect;
        SDL_Rect DstRect;
        DstRect.h = getTileHeight();
        DstRect.w = getTileWidth();
        unsigned char **in_data  = new unsigned char* [getNumLayers()];
        unsigned char **out_data = new unsigned char* [getNumLayers()];
        unsigned int **tiledata = (unsigned int **) out_data;
        for(unsigned i = 0; i < getNumLayers(); i++)
        {
            in_data[i]  = new unsigned char [getLayer(i).getData().getData().size()];
            out_data[i] = new unsigned char [getWidth()*getHeight()*4];
            memcpy( in_data[i] , getLayer(i).getData().getData().c_str() , getLayer(i).getData().getData().size() );
            unsigned char *dec_data = new unsigned char[( getLayer(i).getData().getData().size())];
            TMX_Decode( in_data[i] , dec_data , getLayer(i).getData().getData().size() );
            TMX_Uncompress( dec_data , out_data[i] , ( getLayer(i).getData().getData().size() ), getWidth() * getHeight() * 4,
                           getLayer(i).getData().getCompression().c_str());
        }

        delete[]in_data;

        for (unsigned l = 0; l < TMX_Map::getNumLayers(); l++)
        {

            LayerSurf.push_back(SDL_CreateRGBSurface(0, getWidth()*getTileWidth(), getHeight()*getTileHeight(), 32, rmask, gmask, bmask, amask));
            SDL_SetSurfaceAlphaMod(LayerSurf[l], getLayer(l).getOpacity() * 255);
            for(unsigned int y = 0; y < getHeight(); y++)
            {
                DstRect.y = y * getTileHeight();
                for (unsigned int x = 0; x  < getWidth(); x++)
                {
                    if(tiledata[l][y*getWidth()+x])
                    {
                        DstRect.x = x * getTileWidth();
                        unsigned tilesetindex = findTileset(tiledata[l][y*getWidth()+x]);
                        unsigned srcindex = tiledata[l][y*getWidth()+x] - getTileset(tilesetindex).getGID();
                        SrcRect.h = getTileset(tilesetindex).getTileHeight();
                        SrcRect.w = getTileset(tilesetindex).getTileWidth();
                        float Float_TPL = (float) getTileset(tilesetindex).getImage(0).getWidth()
                                                  / (getTileset(tilesetindex).getTileWidth() + getTileset(tilesetindex).getSpacing());
                        unsigned long Tiles_Per_Line = (long) ceil(Float_TPL);
                        SrcRect.x = srcindex % Tiles_Per_Line * (getTileset(tilesetindex).getTileWidth() + getTileset(tilesetindex).getSpacing());
                        SrcRect.y = srcindex / Tiles_Per_Line * (getTileset(tilesetindex).getTileWidth() + getTileset(tilesetindex).getSpacing());
                        if( SDL_BlitSurface(TileSurf[tilesetindex], &SrcRect, LayerSurf[l], &DstRect) )
						{
							cout << "SDL_BlitSurface Failed: " << SDL_GetError() << endl;
							// if for some reason the application does not implode and instead run this code, we need to know why it crapped us.
							exit (-2);
						}
                    }
                }
            }
            if(getLayer(l).isVisible()) SDL_BlitSurface(LayerSurf[l],NULL, MapSurf, NULL);
        }

        delete[] tiledata;
        for (unsigned l = 0; l < getNumTilesets(); l++)
            SDL_FreeSurface(TileSurf[l]);

        MapTex = SDL_CreateTextureFromSurface(Render, MapSurf);
        SDL_FreeSurface(MapSurf);
    }
    else std::cout << "No way to Populate Map. Quitting..." << endl;
Пример #20
0
	bool isInterestingAtCoord(float x, float y) const {
		return getTile(x / getTileWidth(), y / getTileHeight()).isInteresting;
	}
Пример #21
0
	bool isInterestingAtCoord(const glm::vec2 &pos) {
		return getTile(pos.x / getTileWidth(), pos.y / getTileHeight()).isInteresting;
	}
Пример #22
0
SDL_TMXMap::SDL_TMXMap(const char *Filename)
    :TMX_Map(Filename)
{
    MapSurf = SDL_CreateRGBSurface(0, getWidth()*getTileWidth(), getHeight()*getTileHeight(), 32, rmask, gmask, bmask, amask);
}