自学教程：C++ ARRAYCOUNT函数代码示例

void GetBirchTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks){	int Height = 5 + (a_Noise.IntNoise3DInt(a_BlockX + 64 * a_Seq, a_BlockY, a_BlockZ) % 3);		// Prealloc, so that we don't realloc too often later:	a_LogBlocks.reserve(Height);	a_OtherBlocks.reserve(80);		// The entire trunk, out of logs:	for (int i = Height - 1; i >= 0; --i)	{		a_LogBlocks.push_back(sSetBlock(a_BlockX, a_BlockY + i, a_BlockZ, E_BLOCK_LOG, E_META_LOG_BIRCH));	}	int h = a_BlockY + Height;		// Top layer - just the Plus:	PushCoordBlocks(a_BlockX, h, a_BlockZ, a_OtherBlocks, BigO1, ARRAYCOUNT(BigO1), E_BLOCK_LEAVES, E_META_LEAVES_BIRCH);	a_OtherBlocks.push_back(sSetBlock(a_BlockX, h, a_BlockZ, E_BLOCK_LEAVES, E_META_LEAVES_BIRCH));  // There's no log at this layer	h--;		// Second layer - log, Plus and maybe Corners:	PushCoordBlocks (a_BlockX, h, a_BlockZ, a_OtherBlocks, BigO1, ARRAYCOUNT(BigO1), E_BLOCK_LEAVES, E_META_LEAVES_BIRCH);	PushCornerBlocks(a_BlockX, h, a_BlockZ, a_Seq, a_Noise, 0x5fffffff, a_OtherBlocks, 1, E_BLOCK_LEAVES, E_META_LEAVES_BIRCH);	h--;		// Third and fourth layers - BigO2 and maybe 2*Corners:	for (int Row = 0; Row < 2; Row++)	{		PushCoordBlocks (a_BlockX, h, a_BlockZ, a_OtherBlocks, BigO2, ARRAYCOUNT(BigO2), E_BLOCK_LEAVES, E_META_LEAVES_BIRCH);		PushCornerBlocks(a_BlockX, h, a_BlockZ, a_Seq, a_Noise, 0x3fffffff + Row * 0x10000000, a_OtherBlocks, 2, E_BLOCK_LEAVES, E_META_LEAVES_BIRCH);		h--;	}  // for Row - 2*}

/** Tests rotating the direction 360 degrees. */static void testFullRotation(){	// Rotate 90 degrees CCW four times:	for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i)	{		auto d = g_AllDirections[i];		for (int j = 0; j < 4; ++j)		{			d = cPiece::cConnector::RotateDirectionCCW(d);		}		EXPECT(d == g_AllDirections[i]);	}	// Rotate 90 degrees CW four times:	for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i)	{		auto d = g_AllDirections[i];		for (int j = 0; j < 4; ++j)		{			d = cPiece::cConnector::RotateDirectionCW(d);		}		EXPECT(d == g_AllDirections[i]);	}	// Rotate 180 degrees twice:	for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i)	{		auto d = g_AllDirections[i];		d = cPiece::cConnector::RotateDirection(d);		d = cPiece::cConnector::RotateDirection(d);		EXPECT(d == g_AllDirections[i]);	}}

eMonsterType cMonster::StringToMobType(const AString & a_Name){	AString lcName = StrToLower(a_Name);	// Search MCServer name:	for (size_t i = 0; i < ARRAYCOUNT(g_MobTypeNames); i++)	{		if (strcmp(g_MobTypeNames[i].m_lcName, lcName.c_str()) == 0)		{			return g_MobTypeNames[i].m_Type;		}	}	// Not found. Search Vanilla name:	for (size_t i = 0; i < ARRAYCOUNT(g_MobTypeNames); i++)	{		if (strcmp(StrToLower(g_MobTypeNames[i].m_VanillaName).c_str(), lcName.c_str()) == 0)		{			return g_MobTypeNames[i].m_Type;		}	}	// Not found:	return mtInvalidType;}

void GetDarkoakTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks){	// Pick a height	int Height = 5 + (a_Noise.IntNoise3DInt(a_BlockX + 32 * a_Seq, a_BlockY, a_BlockZ + 32 * a_Seq) / 11) % 4;	// Create the trunk	for (int i = 0; i < Height; i++)	{		a_LogBlocks.push_back(sSetBlock(a_BlockX, a_BlockY + i, a_BlockZ, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));		a_LogBlocks.push_back(sSetBlock(a_BlockX + 1, a_BlockY + i, a_BlockZ, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));		a_LogBlocks.push_back(sSetBlock(a_BlockX, a_BlockY + i, a_BlockZ + 1, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));		a_LogBlocks.push_back(sSetBlock(a_BlockX + 1, a_BlockY + i, a_BlockZ + 1, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));	}	// Create branches	for (int i = 0; i < 3; i++)	{		int x = (a_Noise.IntNoise3DInt(a_BlockX + 32 * a_Seq, a_BlockY * i, a_BlockZ + 32 * a_Seq) % 3) - 1;		int z = (a_Noise.IntNoise3DInt(a_BlockX - 32 * a_Seq, a_BlockY * i, a_BlockZ - 32 * a_Seq) % 3) - 1;		// The branches would end up in the trunk.		if ((x >= a_BlockX) && (x <= a_BlockX + 1) && (z >= a_BlockZ) && (z <= a_BlockZ + 1))		{			NOISE_DATATYPE Val1 = a_Noise.IntNoise2D(x, z);			if (Val1 < 0)			{				x = a_BlockX + ((Val1 < -0.5) ? -1 : 3);			}			else			{				z = a_BlockZ + ((Val1 < 0.5) ? -1 : 3);			}		}		int y = Height - (a_Noise.IntNoise3DInt(a_BlockX + x, a_BlockY * i, a_BlockZ - z) % (Height - (Height / 4)));		for (int Y = y; Y < Height; Y++)		{			a_LogBlocks.push_back(sSetBlock(a_BlockX + x, a_BlockY + Y, a_BlockZ + z, E_BLOCK_NEW_LOG, E_META_NEW_LOG_DARK_OAK_WOOD));		}	}	int hei = a_BlockY + Height - 2;	// The lower two leaves layers are BigO4 with log in the middle and possibly corners:	for (int i = 0; i < 2; i++)	{		PushCoordBlocks(a_BlockX, hei, a_BlockZ, a_OtherBlocks, BigO4, ARRAYCOUNT(BigO4), E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD);		PushCornerBlocks(a_BlockX, hei, a_BlockZ, a_Seq, a_Noise, 0x5fffffff, a_OtherBlocks, 3, E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD);		hei++;	}  // for i < 2	// The top leaves layer is a BigO3 with leaves in the middle and possibly corners:	PushCoordBlocks(a_BlockX, hei, a_BlockZ, a_OtherBlocks, BigO3, ARRAYCOUNT(BigO3), E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD);	PushCornerBlocks(a_BlockX, hei, a_BlockZ, a_Seq, a_Noise, 0x5fffffff, a_OtherBlocks, 3, E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD);	a_OtherBlocks.push_back(sSetBlock(a_BlockX, hei, a_BlockZ, E_BLOCK_NEW_LEAVES, E_META_NEW_LEAVES_DARK_OAK_WOOD));}

void cCompoGenClassic::ComposeTerrain(cChunkDesc & a_ChunkDesc, const cChunkDesc::Shape & a_Shape){	/* The classic composition means:		- 1 layer of grass, 3 of dirt and the rest stone, if the height > sealevel + beachheight		- 3 sand and a 1 sandstone, rest stone if between sealevel and sealevel + beachheight		- water from waterlevel to height, then 3 sand, 1 sandstone, the rest stone, if water depth < beachdepth		- water from waterlevel, then 3 dirt, the rest stone otherwise		- bedrock at the bottom	*/	a_ChunkDesc.FillBlocks(E_BLOCK_AIR, 0);	a_ChunkDesc.SetHeightFromShape(a_Shape);	// The patterns to use for different situations, must be same length!	const BLOCKTYPE PatternGround[] = {m_BlockTop,    m_BlockMiddle, m_BlockMiddle, m_BlockMiddle} ;	const BLOCKTYPE PatternBeach[]  = {m_BlockBeach,  m_BlockBeach,  m_BlockBeach,  m_BlockBeachBottom} ;	const BLOCKTYPE PatternOcean[]  = {m_BlockMiddle, m_BlockMiddle, m_BlockMiddle, m_BlockBottom} ;	static int PatternLength = ARRAYCOUNT(PatternGround);	ASSERT(ARRAYCOUNT(PatternGround) == ARRAYCOUNT(PatternBeach));	ASSERT(ARRAYCOUNT(PatternGround) == ARRAYCOUNT(PatternOcean));	for (int z = 0; z < cChunkDef::Width; z++)	{		for (int x = 0; x < cChunkDef::Width; x++)		{			int Height = a_ChunkDesc.GetHeight(x, z);			const BLOCKTYPE * Pattern;			if (Height > m_SeaLevel + m_BeachHeight)			{				Pattern = PatternGround;			}			else if (Height > m_SeaLevel - m_BeachDepth)			{				Pattern = PatternBeach;			}			else			{				Pattern = PatternOcean;			}			// Fill water from sealevel down to height (if any):			for (int y = m_SeaLevel; y >= Height; --y)			{				a_ChunkDesc.SetBlockType(x, y, z, m_BlockSea);			}			// Fill from height till the bottom:			for (int y = Height; y >= 1; y--)			{				a_ChunkDesc.SetBlockType(x, y, z, (Height - y < PatternLength) ? Pattern[Height - y] : m_BlockBottom);			}			// The last layer is always bedrock:			a_ChunkDesc.SetBlockType(x, 0, z, E_BLOCK_BEDROCK);		}  // for x	}  // for z}

NOISE_DATATYPE cHeiGenBiomal::GetHeightAt(int a_RelX, int a_RelZ, int a_ChunkX, int a_ChunkZ, const cHeiGenBiomal::BiomeNeighbors & a_BiomeNeighbors){	// Sum up how many biomes of each type there are in the neighborhood:	int BiomeCounts[biNumBiomes];	memset(BiomeCounts, 0, sizeof(BiomeCounts));	int Sum = 0;	for (int z = -8; z <= 8; z++)	{		int FinalZ = a_RelZ + z + cChunkDef::Width;		int IdxZ = FinalZ / cChunkDef::Width;		int ModZ = FinalZ % cChunkDef::Width;		int WeightZ = 9 - abs(z);		for (int x = -8; x <= 8; x++)		{			int FinalX = a_RelX + x + cChunkDef::Width;			int IdxX = FinalX / cChunkDef::Width;			int ModX = FinalX % cChunkDef::Width;			EMCSBiome Biome = cChunkDef::GetBiome(a_BiomeNeighbors[IdxX][IdxZ], ModX, ModZ);			if ((Biome < 0) || (Biome >= ARRAYCOUNT(BiomeCounts)))			{				continue;			}			int WeightX = 9 - abs(x);			BiomeCounts[Biome] += WeightX + WeightZ;			Sum += WeightX + WeightZ;		}  // for x	}  // for z		// For each biome type that has a nonzero count, calc its height and add it:	if (Sum > 0)	{		NOISE_DATATYPE Height = 0;		int BlockX = a_ChunkX * cChunkDef::Width + a_RelX;		int BlockZ = a_ChunkZ * cChunkDef::Width + a_RelZ;		for (int i = 0; i < ARRAYCOUNT(BiomeCounts); i++)		{			if (BiomeCounts[i] == 0)			{				continue;			}			NOISE_DATATYPE oct1 = m_Noise.CubicNoise2D(BlockX * m_GenParam[i].m_HeightFreq1, BlockZ * m_GenParam[i].m_HeightFreq1) * m_GenParam[i].m_HeightAmp1;			NOISE_DATATYPE oct2 = m_Noise.CubicNoise2D(BlockX * m_GenParam[i].m_HeightFreq2, BlockZ * m_GenParam[i].m_HeightFreq2) * m_GenParam[i].m_HeightAmp2;			NOISE_DATATYPE oct3 = m_Noise.CubicNoise2D(BlockX * m_GenParam[i].m_HeightFreq3, BlockZ * m_GenParam[i].m_HeightFreq3) * m_GenParam[i].m_HeightAmp3;			Height += BiomeCounts[i] * (m_GenParam[i].m_BaseHeight + oct1 + oct2 + oct3);		}		NOISE_DATATYPE res = Height / Sum;		return std::min((NOISE_DATATYPE)250, std::max(res, (NOISE_DATATYPE)5));	}		// No known biome around? Weird. Return a bogus value:	ASSERT(!"cHeiGenBiomal: Biome sum failed, no known biome around");	return 5;}

/* * Print the allocated/freed map of a single kernel heap page. */staticvoidsubpage_stats(struct pageref *pr){	vaddr_t prpage, fla;	struct freelist *fl;	int blktype;	unsigned i, n, index;	uint32_t freemap[PAGE_SIZE / (SMALLEST_SUBPAGE_SIZE*32)];	checksubpage(pr);	KASSERT(spinlock_do_i_hold(&kmalloc_spinlock));	/* clear freemap[] */	for (i=0; i<ARRAYCOUNT(freemap); i++) {		freemap[i] = 0;	}	prpage = PR_PAGEADDR(pr);	blktype = PR_BLOCKTYPE(pr);	KASSERT(blktype >= 0 && blktype < NSIZES);	/* compute how many bits we need in freemap and assert we fit */	n = PAGE_SIZE / sizes[blktype];	KASSERT(n <= 32 * ARRAYCOUNT(freemap));	if (pr->freelist_offset != INVALID_OFFSET) {		fla = prpage + pr->freelist_offset;		fl = (struct freelist *)fla;		for (; fl != NULL; fl = fl->next) {			fla = (vaddr_t)fl;			index = (fla-prpage) / sizes[blktype];			KASSERT(index<n);			freemap[index/32] |= (1<<(index%32));		}	}	kprintf("at 0x%08lx: size %-4lu  %u/%u free/n",		(unsigned long)prpage, (unsigned long) sizes[blktype],		(unsigned) pr->nfree, n);	kprintf("   ");	for (i=0; i<n; i++) {		int val = (freemap[i/32] & (1<<(i%32)))!=0;		kprintf("%c", val ? '.' : '*');		if (i%64==63 && i<n-1) {			kprintf("/n   ");		}	}	kprintf("/n");}

void cServerHandleImpl::Callback(evconnlistener * a_Listener, evutil_socket_t a_Socket, sockaddr * a_Addr, int a_Len, void * a_Self){	// Cast to true self:	cServerHandleImpl * Self = reinterpret_cast<cServerHandleImpl *>(a_Self);	ASSERT(Self != nullptr);	ASSERT(Self->m_SelfPtr != nullptr);	// Get the textual IP address and port number out of a_Addr:	char IPAddress[128];	UInt16 Port = 0;	switch (a_Addr->sa_family)	{		case AF_INET:		{			sockaddr_in * sin = reinterpret_cast<sockaddr_in *>(a_Addr);			evutil_inet_ntop(AF_INET, &(sin->sin_addr), IPAddress, ARRAYCOUNT(IPAddress));			Port = ntohs(sin->sin_port);			break;		}		case AF_INET6:		{			sockaddr_in6 * sin6 = reinterpret_cast<sockaddr_in6 *>(a_Addr);			evutil_inet_ntop(AF_INET6, &(sin6->sin6_addr), IPAddress, ARRAYCOUNT(IPAddress));			Port = ntohs(sin6->sin6_port);			break;		}	}	// Call the OnIncomingConnection callback to get the link callbacks to use:	cTCPLink::cCallbacksPtr LinkCallbacks = Self->m_ListenCallbacks->OnIncomingConnection(IPAddress, Port);	if (LinkCallbacks == nullptr)	{		// Drop the connection:		evutil_closesocket(a_Socket);		return;	}	// Create a new cTCPLink for the incoming connection:	cTCPLinkImplPtr Link = std::make_shared<cTCPLinkImpl>(a_Socket, LinkCallbacks, Self->m_SelfPtr, a_Addr, static_cast<socklen_t>(a_Len));	{		cCSLock Lock(Self->m_CS);		Self->m_Connections.push_back(Link);	}  // Lock(m_CS)	LinkCallbacks->OnLinkCreated(Link);	Link->Enable(Link);	// Call the OnAccepted callback:	Self->m_ListenCallbacks->OnAccepted(*Link);}

void GetAppleBushImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks){	a_OtherBlocks.reserve(3 + ARRAYCOUNT(BigO2) + ARRAYCOUNT(BigO1));		int hei = a_BlockY;	a_LogBlocks.push_back(sSetBlock(a_BlockX, hei, a_BlockZ, E_BLOCK_LOG, E_META_LOG_JUNGLE));	PushCoordBlocks(a_BlockX, hei, a_BlockZ, a_OtherBlocks, BigO2, ARRAYCOUNT(BigO2), E_BLOCK_LEAVES, E_META_LEAVES_APPLE);	hei++;		a_OtherBlocks.push_back(sSetBlock(a_BlockX, hei, a_BlockZ, E_BLOCK_LEAVES, E_META_LEAVES_APPLE));	PushCoordBlocks(a_BlockX, hei, a_BlockZ, a_OtherBlocks, BigO1, ARRAYCOUNT(BigO1), E_BLOCK_LEAVES, E_META_LEAVES_APPLE);	hei++;		a_OtherBlocks.push_back(sSetBlock(a_BlockX, hei, a_BlockZ, E_BLOCK_LEAVES, E_META_LEAVES_APPLE));}

/** Tests that rotating a direction in one way and then the opposite way produces the original direction. */static void testBackAndForth(){	for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i)	{		auto rotated = cPiece::cConnector::RotateDirectionCW(g_AllDirections[i]);		auto back = cPiece::cConnector::RotateDirectionCCW(rotated);		EXPECT(back == g_AllDirections[i]);	}	for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i)	{		auto rotated = cPiece::cConnector::RotateDirectionCCW(g_AllDirections[i]);		auto back = cPiece::cConnector::RotateDirectionCW(rotated);		EXPECT(back == g_AllDirections[i]);	}}

void cEndGen::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap){	if (IsChunkOutsideRange(a_ChunkX, a_ChunkZ))	{		for (unsigned int i = 0; i < ARRAYCOUNT(a_HeightMap); i++)		{			a_HeightMap[i] = 0;		}		return;	}	PrepareState(a_ChunkX, a_ChunkZ);	int MaxY = std::min((int)(1.75 * m_IslandSizeY + 1), cChunkDef::Height - 1);	for (int z = 0; z < cChunkDef::Width; z++)	{		for (int x = 0; x < cChunkDef::Width; x++)		{			cChunkDef::SetHeight(a_HeightMap, x, z, MaxY);			for (int y = MaxY; y > 0; y--)			{				if (m_NoiseArray[y * 17 * 17 + z * 17 + x] <= 0)				{					cChunkDef::SetHeight(a_HeightMap, x, z, y);					break;				}			}  // for y		}  // for x	}  // for z}

void cBioGenConstant::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap){	for (size_t i = 0; i < ARRAYCOUNT(a_BiomeMap); i++)	{		a_BiomeMap[i] = m_Biome;	}}

void cBioGenMultiStepMap::BuildTemperatureHumidityMaps(int a_ChunkX, int a_ChunkZ, IntMap & a_TemperatureMap, IntMap & a_HumidityMap){	// Linear interpolation over 8x8 blocks; use double for better precision:	DblMap TemperatureMap;	DblMap HumidityMap;	for (int z = 0; z < 17; z += 8)	{		float NoiseCoordZ = (float)(a_ChunkZ * cChunkDef::Width + z) / m_LandBiomesSize;		for (int x = 0; x < 17; x += 8)		{			float NoiseCoordX = (float)(a_ChunkX * cChunkDef::Width + x) / m_LandBiomesSize;					double NoiseT = m_Noise1.CubicNoise2D(    NoiseCoordX,     NoiseCoordZ);			NoiseT += 0.5 * m_Noise2.CubicNoise2D(2 * NoiseCoordX, 2 * NoiseCoordZ);			NoiseT += 0.1 * m_Noise3.CubicNoise2D(8 * NoiseCoordX, 8 * NoiseCoordZ);			TemperatureMap[x + 17 * z] = NoiseT;			double NoiseH = m_Noise4.CubicNoise2D(    NoiseCoordX,     NoiseCoordZ);			NoiseH += 0.5 * m_Noise5.CubicNoise2D(2 * NoiseCoordX, 2 * NoiseCoordZ);			NoiseH += 0.1 * m_Noise6.CubicNoise2D(8 * NoiseCoordX, 8 * NoiseCoordZ);			HumidityMap[x + 17 * z] = NoiseH;		}  // for x	}  // for z	LinearUpscale2DArrayInPlace<17, 17, 8, 8>(TemperatureMap);	LinearUpscale2DArrayInPlace<17, 17, 8, 8>(HumidityMap);		// Re-map into integral values in [0 .. 255] range:	for (size_t idx = 0; idx < ARRAYCOUNT(a_TemperatureMap); idx++)	{		a_TemperatureMap[idx] = std::max(0, std::min(255, (int)(128 + TemperatureMap[idx] * 128)));		a_HumidityMap[idx]    = std::max(0, std::min(255, (int)(128 + HumidityMap[idx]    * 128)));	}}

AString DimensionToString(eDimension a_Dimension){	// Decode using a built-in map:	static struct	{		eDimension m_Dimension;		const char * m_String;	} DimensionMap[] =	{		{ dimOverworld, "Overworld" },		{ dimNether, "Nether" },		{ dimEnd, "End" },	};	for (size_t i = 0; i < ARRAYCOUNT(DimensionMap); i++)	{		if (DimensionMap[i].m_Dimension == a_Dimension)		{			return DimensionMap[i].m_String;		}	}  // for i - DimensionMap[]	// Not found	LOGWARNING("Unknown dimension: /"%i/". Setting to Overworld", static_cast<int>(a_Dimension));	return "Overworld";}

void cHeiGenFlat::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap){	for (size_t i = 0; i < ARRAYCOUNT(a_HeightMap); i++)	{		a_HeightMap[i] = m_Height;	}}

bool cFireSimulator::CanStartFireInBlock(cChunk * a_NearChunk, int a_RelX, int a_RelY, int a_RelZ){	BLOCKTYPE  BlockType;	NIBBLETYPE BlockMeta;	if (!a_NearChunk->UnboundedRelGetBlock(a_RelX, a_RelY, a_RelZ, BlockType, BlockMeta))	{		// The chunk is not accessible		return false;	}		if (BlockType != E_BLOCK_AIR)	{		// Only an air block can be replaced by a fire block		return false;	}		for (size_t i = 0; i < ARRAYCOUNT(gNeighborCoords); i++)	{		if (!a_NearChunk->UnboundedRelGetBlock(a_RelX + gNeighborCoords[i].x, a_RelY + gNeighborCoords[i].y, a_RelZ + gNeighborCoords[i].z, BlockType, BlockMeta))		{			// Neighbor inaccessible, skip it while evaluating			continue;		}		if (IsFuel(BlockType))		{			return true;		}	}  // for i - Coords[]	return false;}

void AutowiringEnclosure::OnTestEnd(const testing::TestInfo& info) {  // Verify we can grab the test case back out and that the pointer is correct:  Autowired<TestInfoProxy> ti;  Autowired<AutowiringEnclosureExceptionFilter> ecef;  auto ctxt = ecef ? ecef->GetContext() : nullptr;  // Unconditionally reset the global context as the current context  AutoGlobalContext()->SetCurrent();  // Global initialization tests are special, we don't bother checking closure principle on them:  if(!strcmp("GlobalInitTest", info.test_case_name()))    return;  // Need to make sure we got back our exception filter before continuing:  ASSERT_TRUE(ecef.IsAutowired()) << "Failed to find the enclosed context exception filter; unit test may have incorrectly reset the enclosing context before returning";  // Now try to tear down the test context enclosure:  ctxt->SignalShutdown();  // Do not allow teardown to take more than 250 milliseconds or so  if(!ctxt->Wait(std::chrono::milliseconds(250))) {    // Critical error--took too long to tear down    assert(false);  }  static const char s_autothrow[] = "AUTOTHROW_";  if(!strncmp(s_autothrow, info.name(), ARRAYCOUNT(s_autothrow) - 1))    // Throw expected, end here    return;  // If an exception occurred somewhere, report it:  ASSERT_FALSE(ecef->m_excepted)    << "An unhandled exception occurred in this context" << std::endl    << "[" << (ecef->m_ti ? ecef->m_ti->name() : "unknown") << "] " << ecef->m_what;}

void cCompoGenBiomal::FillColumnClay(int a_RelX, int a_RelZ, int a_Height, cChunkDef::BlockTypes & a_BlockTypes){	BLOCKTYPE Pattern[] =	{		E_BLOCK_HARDENED_CLAY,		E_BLOCK_HARDENED_CLAY,		E_BLOCK_HARDENED_CLAY,		E_BLOCK_HARDENED_CLAY,	} ;	FillColumnPattern(a_RelX, a_RelZ, a_Height, a_BlockTypes, Pattern, ARRAYCOUNT(Pattern));		for (int y = a_Height - ARRAYCOUNT(Pattern); y > 0; y--)	{		cChunkDef::SetBlock(a_BlockTypes, a_RelX, y, a_RelZ, E_BLOCK_STONE);	}}

void NodeAddModule(const tchar_t* Path,int Id,int64_t Date,bool_t Load,bool_t Tmp){	context* p = Context();	LockEnter(p->NodeLock);	if (ArrayAppend(&p->NodeModule,NULL,sizeof(nodemodule),256))	{		int No = ARRAYCOUNT(p->NodeModule,nodemodule)-1;		nodemodule* Module = ARRAYBEGIN(p->NodeModule,nodemodule)+No;		memset(Module,0,sizeof(nodemodule));		Module->Id = Id;		Module->Date = Date;		Module->Tmp = Tmp;		StringAdd(1,MODULE_PATH,No,Path);		if (Load)		{			p->LoadModuleNo = No;			Module->Module = NodeLoadModule(Path,&Module->Id,&Module->Func,&Module->Db);			p->LoadModuleNo = 0;#ifdef PLUGINCLEANUP			FreeModule(Module);#endif		}	}	LockLeave(p->NodeLock);}

EMCSBiome StringToBiome(const AString & a_BiomeString){	// If it is a number, return it:	int res = atoi(a_BiomeString.c_str());	if ((res != 0) || (a_BiomeString.compare("0") == 0))	{		if ((res >= biFirstBiome) && (res < biNumBiomes))		{			return (EMCSBiome)res;		}		else if ((res >= biFirstVariantBiome) && (res < biNumVariantBiomes))		{			return (EMCSBiome)res;		}		// It was an invalid number		return biInvalidBiome;	}		for (size_t i = 0; i < ARRAYCOUNT(g_BiomeMap); i++)	{		if (NoCaseCompare(g_BiomeMap[i].m_String, a_BiomeString) == 0)		{			return g_BiomeMap[i].m_Biome;		}	}  // for i - BiomeMap[]	return biInvalidBiome;}

static NOINLINE int FindModule(context* p,const tchar_t* Path,int Id){	// important to find from the begining for Palm OS 	// so the exising plugins are found first	int No,Count;	int Result = -1;	LockEnter(p->NodeLock);	Count = ARRAYCOUNT(p->NodeModule,nodemodule);	if (!Path) Path = T("");	for (No=0;No<Count;++No)	{		bool_t SameId = ARRAYBEGIN(p->NodeModule,nodemodule)[No].Id == Id;		bool_t SameName = TcsICmp(Path,StringDef(MODULE_PATH,No))==0;		if (SameId && Id!=0) // same Id means same module			SameName = 1;		if (SameName && !Id)			SameId = 1;		if (SameId && SameName)		{			Result = No;			break;		}	}	LockLeave(p->NodeLock);	return Result;}

int cFireSimulator::GetBurnStepTime(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ){	if (a_RelY > 0)	{		BLOCKTYPE BlockBelow = a_Chunk->GetBlock(a_RelX, a_RelY - 1, a_RelZ);		if (IsForever(BlockBelow))		{			// Is burning atop of netherrack, burn forever (re-check in 10 sec)			return 10000;		}		if (IsFuel(BlockBelow))		{			return m_BurnStepTimeFuel;		}	}	if ((a_RelY < cChunkDef::Height - 1) && IsFuel(a_Chunk->GetBlock(a_RelX, a_RelY - 1, a_RelZ)))	{		return m_BurnStepTimeFuel;	}		for (int i = 0; i < ARRAYCOUNT(gCrossCoords); i++)	{		BLOCKTYPE  BlockType;		NIBBLETYPE BlockMeta;		if (a_Chunk->UnboundedRelGetBlock(a_RelX + gCrossCoords[i].x, a_RelY, a_RelZ + gCrossCoords[i].z, BlockType, BlockMeta))		{			if (IsFuel(BlockType))			{				return m_BurnStepTimeFuel;			}		}	}  // for i - gCrossCoords[]	return m_BurnStepTimeNonfuel;}

void cNoise3DGenerator::GenerateBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a_BiomeMap){	for (size_t i = 0; i < ARRAYCOUNT(a_BiomeMap); i++)	{		a_BiomeMap[i] = biExtremeHills;	}}

staticintcmd_mount(int nargs, char **args){	char *fstype;	char *device;	unsigned i;	if (nargs != 3) {		kprintf("Usage: mount fstype device:/n");		return EINVAL;	}	fstype = args[1];	device = args[2];	/* Allow (but do not require) colon after device name */	if (device[strlen(device)-1]==':') {		device[strlen(device)-1] = 0;	}	for (i=0; i<ARRAYCOUNT(mounttable); i++) {		if (!strcmp(mounttable[i].name, fstype)) {			return mounttable[i].func(device);		}	}	kprintf("Unknown filesystem type %s/n", fstype);	return EINVAL;}

cObjective::eType cObjective::StringToType(const AString & a_Name){	static struct	{		eType m_Type;		const char * m_String;	} TypeMap [] =	{		{otDummy,              "dummy"              },		{otDeathCount,         "deathCount"         },		{otPlayerKillCount,    "playerKillCount"    },		{otTotalKillCount,     "totalKillCount"     },		{otHealth,             "health"             },		{otAchievement,        "achievement"        },		{otStat,               "stat"               },		{otStatItemCraft,      "stat.craftItem"     },		{otStatItemUse,        "stat.useItem"       },		{otStatItemBreak,      "stat.breakItem"     },		{otStatBlockMine,      "stat.mineBlock"     },		{otStatEntityKill,     "stat.killEntity"    },		{otStatEntityKilledBy, "stat.entityKilledBy"}	};	for (size_t i = 0; i < ARRAYCOUNT(TypeMap); i++)	{		if (NoCaseCompare(TypeMap[i].m_String, a_Name) == 0)		{			return TypeMap[i].m_Type;		}	}  // for i - TypeMap[]	return otDummy;}

void cPrefab::ParseCharMap(CharMap & a_CharMapOut, const char * a_CharMapDef){	ASSERT(a_CharMapDef != NULL);		// Initialize the charmap to all-invalid values:	for (size_t i = 0; i < ARRAYCOUNT(a_CharMapOut); i++)	{		a_CharMapOut[i].m_BlockType = 0;		a_CharMapOut[i].m_BlockMeta = 16;  // Mark unassigned entries with a meta that is impossible otherwise	}		// Process the lines in the definition:	AStringVector Lines = StringSplitAndTrim(a_CharMapDef, "/n");	for (AStringVector::const_iterator itr = Lines.begin(), end = Lines.end(); itr != end; ++itr)	{		AStringVector CharDef = StringSplitAndTrim(*itr, ":");		size_t NumElements = CharDef.size();		if ((NumElements < 2) || CharDef[0].empty() || CharDef[1].empty())		{			LOGWARNING("Bad prefab CharMap definition line: /"%s/", skipping.", itr->c_str());			continue;		}		unsigned char Src = (unsigned char)CharDef[0][0];		ASSERT(a_CharMapOut[Src].m_BlockMeta == 16);  // This letter has not been assigned yet?		a_CharMapOut[Src].m_BlockType = (BLOCKTYPE)atoi(CharDef[1].c_str());		NIBBLETYPE BlockMeta = 0;		if ((NumElements >= 3) && !CharDef[2].empty())		{			BlockMeta = (NIBBLETYPE)atoi(CharDef[2].c_str());			ASSERT((BlockMeta <= 15));		}		a_CharMapOut[Src].m_BlockMeta = BlockMeta;	}  // for itr - Lines[]}

    virtual void HeightMap(const cChunkDef::HeightMap * a_Heightmap) override    {        // Copy the entire heightmap, distribute it into the 3x3 chunk blob:        typedef struct {            HEIGHTTYPE m_Row[16];        } ROW;        const ROW * InputRows  = reinterpret_cast<const ROW *>(a_Heightmap);        ROW * OutputRows = reinterpret_cast<ROW *>(m_HeightMap);        int InputIdx = 0;        int OutputIdx = m_ReadingChunkX + m_ReadingChunkZ * cChunkDef::Width * 3;        for (int z = 0; z < cChunkDef::Width; z++)        {            OutputRows[OutputIdx] = InputRows[InputIdx++];            OutputIdx += 3;        }  // for z        // Find the highest block in the entire chunk, use it as a base for m_MaxHeight:        HEIGHTTYPE MaxHeight = m_MaxHeight;        for (size_t i = 0; i < ARRAYCOUNT(*a_Heightmap); i++)        {            if ((*a_Heightmap)[i] > MaxHeight)            {                MaxHeight = (*a_Heightmap)[i];            }        }        m_MaxHeight = MaxHeight;    }

void TestError_s( void ){    wchar_t     error[ 256 ];    size_t      errlen;    int     violations = NumViolations;    errlen = wcserrorlen_s( EBADF );    VERIFY( errlen != 0 );    VERIFY( wcserror_s( error, ARRAYCOUNT( error ), EBADF ) == 0 ); /* get an error string */    VERIFY( wcslen( error ) != 0 );    VERIFY( wcserror_s( error, errlen - 1, EBADF ) != 0 ); /* truncated error string */    VERIFY( wcscmp( error + errlen - 5, L"..." ) == 0 ); /* really truncated? */    VERIFY( NumViolations == violations );    //rt constraints    VERIFY( wcserror_s( NULL, errlen - 1, EBADF ) != 0 );    VERIFY( NumViolations == ++violations );    VERIFY( wcserror_s( error, 0, EBADF ) != 0 );    VERIFY( NumViolations == ++violations );#if RSIZE_MAX != SIZE_MAX    VERIFY( wcserror_s( error, ~0, EBADF ) != 0 );    VERIFY( NumViolations == ++violations );#endif}

cGridStructGen::cStructurePtr cUnderwaterBaseGen::CreateStructure(int a_OriginX, int a_OriginZ){	// Generate the biomes for the chunk surrounding the origin:	int ChunkX, ChunkZ;	cChunkDef::BlockToChunk(a_OriginX, a_OriginZ, ChunkX, ChunkZ);	cChunkDef::BiomeMap Biomes;	m_BiomeGen.GenBiomes(ChunkX, ChunkZ, Biomes);	// Check if all the biomes are ocean:	// If just one is not, no base is created, because it's likely that an unfriendly biome is too close	for (size_t i = 0; i < ARRAYCOUNT(Biomes); i++)	{		switch (Biomes[i])		{			case biOcean:			case biDeepOcean:			{				// These biomes allow underwater bases				break;			}			default:			{				// base-unfriendly biome, bail out with zero structure:				return cStructurePtr();			}		}  // switch (Biomes[i])	}  // for i - Biomes[]	// Create a base based on the chosen prefabs:	return cStructurePtr(new cUnderwaterBase(m_Seed, a_OriginX, a_OriginZ, m_MaxDepth, m_MaxSize));}