Пример #1
0
//***************************************************************************************************
//	Initialize
//***************************************************************************************************
void eCTerrainTileList::Initialize(GEUInt a_iCapacity, const GEU32* a_arrTileMaterialTypeIndex, GEUInt a_iLodCount, GEUInt a_iBaseLodDimension)
{
	Clear();

	m_pActiveList1			= (eSTerrainTileData**)GE_MALLOC(sizeof(eSTerrainTileData*) * a_iCapacity);
	m_pActiveList2			= (eSTerrainTileData**)GE_MALLOC(sizeof(eSTerrainTileData*) * a_iCapacity);

	m_pActiveList		= m_pActiveList1;
	m_iListCapacity		= a_iCapacity;
	m_iListCount		= 0;

	m_iLodCount			= GEMin(a_iLodCount, s_iTileListMaxLodLevelCount);

	//
	GEUInt iArrayOffset		= 0;
	GEUInt iArrayDimension	= a_iBaseLodDimension;

	for (GEUInt iLodLevel = 0; iLodLevel <= s_iTileListMaxLodLevelCount; ++iLodLevel)
	{
		m_arrOffset[iLodLevel]			= iArrayOffset;
		m_arrDimension[iLodLevel]		= iArrayDimension;
		m_arrTileDimension[iLodLevel]	= s_iTileDimension << iLodLevel;

		GEUInt iDistanceThreshold = 16 + ((s_iTileDimension << iLodLevel) * 2);
		m_arrThresholdSqr[iLodLevel]		= iDistanceThreshold * iDistanceThreshold;

		iArrayOffset += (iArrayDimension * iArrayDimension);
		iArrayDimension = iArrayDimension >> 1;
	}

	CreateTiles(a_arrTileMaterialTypeIndex);

	CreateDefaultActiveTileList();
}
Пример #2
0
Map::Map(int randSeed, int exponent, float startValue)
{
	// Get seed for noise
	setRandom(randSeed);
	// Initiate point-map
	this->chunkSize = pow(2, exponent) + 1;// +1 gives the map a mid-point
	seed = startValue;
	ds = new float*[chunkSize];// 33x33, 17x17, etc
	for (int i = 0; i < chunkSize; i++)
	{
		ds[i] = new float[chunkSize];
	}
	chunkSize--;
	// Initiate map
	tiles = new TileClass*[chunkSize];// 32x32, 16x16, etc
	baseTiles = new BaseTile*[chunkSize];
	for (int i = 0; i < chunkSize; i++)
	{
		tiles[i] = new TileClass[chunkSize];
		baseTiles[i] = new BaseTile[chunkSize];
	}

	// Create noise - algorithm usage
	DiamondSquare((startValue * 0.5f), 0.76789f);

	// Create Tile-based map
	CreateTiles();
}
Пример #3
0
Map::Map()
{
	// Get seed for noise
	setRandom(1);
	// Initiate point-map
	this->chunkSize = pow(2, 5) + 1;// +1 gives the map a mid-point
	seed = 60.0f;
	ds = new float*[chunkSize];// 33x33, 17x17, etc
	for (int i = 0; i < chunkSize; i++)
	{
		ds[i] = new float[chunkSize];
	}
	chunkSize--;
	// Initiate map
	tiles = new TileClass*[chunkSize];// 32x32, 16x16, etc
	baseTiles = new BaseTile*[chunkSize];
	for (int i = 0; i < chunkSize; i++)
	{
		tiles[i] = new TileClass[chunkSize];
		baseTiles[i] = new BaseTile[chunkSize];
	}

	// Create noise - algorithm usage
	DiamondSquare(30.0f, 0.76789f);

	// Create Tile-based map
	CreateTiles();
}
Пример #4
0
	TileMap::TileMap(const std::string &path, const float width, const float height, int InMaxMapCellX, int InMaxMapCellY)
	{
		m_FrameSize.SetRect(0, 0, width, height);
		m_TileTexture = Singleton<Assets>::GetSingleton()->RequestTexture(path);
		assert(m_TileTexture);
		m_MaxCellXCount = static_cast<int>(m_TileTexture->width() / width);
		m_MaxCellYCount = static_cast<int>(m_TileTexture->height() / height);
		m_MaxMapCellX = InMaxMapCellX;
		m_MaxMapCellY = InMaxMapCellY;
		m_FrameCount = m_MaxCellXCount * m_MaxCellYCount;
		CreateTiles();
	}
Пример #5
0
bool Terrain::Load(const std::string& file)
{
    Unload();

    cFile f;
    if(!f.Open(file, FFileOpenFlags::Read | FFileOpenFlags::OpenExisting))
        return false;

    int cells_count = (int)m_Dimensions.Volume();

    if(f.GetSize() < cells_count * sizeof(unsigned short))
        return false;

    if(!CreateTiles(cells_count))
        return false;

    FixedArray<unsigned short> ids(cells_count);

    if(!f.Read(ids.GetDataPointer(), ids.GetDataSize()))
        return false;

    m_TextureSetPrefix = "city";
    m_TextureCache.SetTextureManager(Game::GetSingleton()->GetTextureManager());
    CacheTextures();

    vec3 pos = vec3::ZERO;
    int mx = (int)m_Dimensions.x;
    int mz = (int)m_Dimensions.z;

    for(int i = 0; i < ids.GetSize() && i < (*m_Tiles).GetSize(); ++i)
    {
        pos.y = (float)(i / (mx * mz));
        pos.z = (float)(i % mz);
        pos.x = float((i % (mx * mz) - i % mz) / mz);

        (*m_Tiles)[i].m_Id = ids[i];
        (*m_Tiles)[i].m_Pos = pos;
    }

    m_Loaded = true;

    return true;
}
Пример #6
0
	void Map::ResetMap()
	{
		
		offSetBeforeRightClickDragY_ = 0;
		offSetBeforeRightClickDragX_ = 0;
		CreateTiles(10,10);
		for(int i = 0; i < width_; i++)
		{
			for(int j = 0; j < height_; j++)
			{
				tiles_[i][j].SetColor(al_map_rgb_f(1,1,1));//sets all tiles to grey
				tiles_[i][j].SetTileType(EnumDLL::TILETYPE::EMPTYTILE);
				tiles_[i][j].SetCurrentPosition(i,j);
				tiles_[i][j].SetWidth(1);
				tiles_[i][j].SetHeight(1);
			}
		}

		
		mapXoffset_ = settings_->GetScreenWidth()/2-width_*Constants::TileSize/2;
		mapYoffset_ = settings_->GetScreenHeight()/2-height_*Constants::TileSize/2;

		PreCalc();
	}