Merge pull request #292 from SamJBarney/MobSpawning

Mob Spawning based on light values

source/Chunk.cpp

@@ -519,32 +519,28 @@ void cChunk::SpawnMobs(cMobSpawner& a_MobSpawner)
 			ASSERT(Try_Y > 0);
 			ASSERT(Try_Y < cChunkDef::Height-1);
 			
-			BLOCKTYPE BlockType;
+			EMCSBiome Biome = m_ChunkMap->GetBiomeAt (Try_X, Try_Z);
-			NIBBLETYPE BlockMeta;
+			// MG TODO :
-			BLOCKTYPE BlockType_below;
+			// Moon cycle (for slime)
-			NIBBLETYPE BlockMeta_below;
+			// check player and playerspawn presence < 24 blocks
-			BLOCKTYPE BlockType_above;
+			// check mobs presence on the block
-			NIBBLETYPE BlockMeta_above;
+
-			if (UnboundedRelGetBlock(Try_X, Try_Y  , Try_Z, BlockType, BlockMeta) &&
+			// MG TODO : check that "Level" really means Y
-				UnboundedRelGetBlock(Try_X, Try_Y-1, Try_Z, BlockType_below, BlockMeta_below)&&
+			
-				UnboundedRelGetBlock(Try_X, Try_Y+1, Try_Z, BlockType_above, BlockMeta_above)
+			NIBBLETYPE SkyLight = 0;
-				)
+
+			NIBBLETYPE BlockLight = 0;
+
+			if (IsLightValid())
 			{
-				EMCSBiome Biome = m_ChunkMap->GetBiomeAt (Try_X, Try_Z);
+				cEntity* newMob = a_MobSpawner.TryToSpawnHere(this, Try_X, Try_Y, Try_Z, Biome, MaxNbOfSuccess);
-				// MG TODO :
-				// Moon cycle (for slime)
-				// check player and playerspawn presence < 24 blocks
-				// check mobs presence on the block
-
-				// MG TODO: fix the "light" thing, I'm pretty sure that UnboundedRelGetBlock s not returning the right thing
-
-				// MG TODO : check that "Level" really means Y
-				cEntity* newMob = a_MobSpawner.TryToSpawnHere(BlockType, BlockMeta, BlockType_below, BlockMeta_below, BlockType_above, BlockMeta_above, Biome, Try_Y, MaxNbOfSuccess);
 				if (newMob)
 				{
 					int WorldX, WorldY, WorldZ;
 					PositionToWorldPosition(Try_X, Try_Y, Try_Z, WorldX, WorldY, WorldZ);
-					newMob->SetPosition(WorldX, WorldY, WorldZ);
+					double ActualX = WorldX + 0.5;
+					double ActualZ = WorldZ + 0.5;
+					newMob->SetPosition(ActualX, WorldY, ActualZ);
 					LOGD("Spawning %s #%i at %d,%d,%d",newMob->GetClass(),newMob->GetUniqueID(),WorldX, WorldY, WorldZ);
 					NumberOfSuccess++;
 				}
@@ -2790,6 +2786,17 @@ Vector3i cChunk::PositionToWorldPosition(int a_RelX, int a_RelY, int a_RelZ)
 
 
 
+NIBBLETYPE cChunk::GetTimeAlteredLight(NIBBLETYPE a_Skylight) const
+{
+	a_Skylight -= m_World->GetSkyDarkness();
+	// Because NIBBLETYPE is unsigned, we clamp it to 0 .. 15 by checking for values above 15
+	return (a_Skylight < 16)? a_Skylight : 0;
+}
+
+
+
+
+
 #if !C_CHUNK_USE_INLINE
 # include "cChunk.inl.h"
 #endif

source/Chunk.h

@@ -329,6 +329,10 @@ public:
 	/// Same as QueueTickBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s in such a case), ignores unsuccessful attempts
 	void UnboundedQueueTickBlock(int a_RelX, int a_RelY, int a_RelZ);
 
+	/// Light alterations based on time
+	NIBBLETYPE GetTimeAlteredLight(NIBBLETYPE a_Skylight) const;
+
+
 	// Simulator data:
 	cFireSimulatorChunkData & GetFireSimulatorData (void) { return m_FireSimulatorData; }
 	cFluidSimulatorData *     GetWaterSimulatorData(void) { return m_WaterSimulatorData; }

source/MobSpawner.cpp

@@ -124,87 +124,104 @@ cMonster::eType cMobSpawner::ChooseMobType(EMCSBiome a_Biome)
 
 
 
-bool cMobSpawner::CanSpawnHere(cMonster::eType a_MobType, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, BLOCKTYPE a_BlockType_below, NIBBLETYPE a_BlockMeta_below, BLOCKTYPE a_BlockType_above, NIBBLETYPE a_BlockMeta_above, EMCSBiome a_Biome, int a_Level)
+bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, cMonster::eType a_MobType, EMCSBiome a_Biome)
 {
-	bool toReturn = false;
+	BLOCKTYPE TargetBlock;
-	std::set<cMonster::eType>::iterator itr = m_AllowedTypes.find(a_MobType);
+	if (m_AllowedTypes.find(a_MobType) != m_AllowedTypes.end() && a_Chunk->UnboundedRelGetBlockType(a_RelX, a_RelY, a_RelZ, TargetBlock))
-	if (itr != m_AllowedTypes.end())
 	{
-		// MG TODO : find a nicer paging
+		NIBBLETYPE BlockLight = a_Chunk->GetBlockLight(a_RelX, a_RelY, a_RelZ);
-		if (a_MobType == cMonster::mtSquid)
+		NIBBLETYPE SkyLight = a_Chunk->GetSkyLight(a_RelX, a_RelY, a_RelZ);
+		BLOCKTYPE BlockAbove = a_Chunk->GetBlock(a_RelX, a_RelY + 1, a_RelZ);
+		BLOCKTYPE BlockBelow = a_Chunk->GetBlock(a_RelX, a_RelY - 1, a_RelZ);
+
+		SkyLight = a_Chunk->GetTimeAlteredLight(SkyLight);
+
+		switch(a_MobType)
 		{
-			toReturn = (
+			case cMonster::mtSquid:
-				IsBlockLiquid(a_BlockType) &&
+				return IsBlockWater(TargetBlock) && (a_RelY >= 45) && (a_RelY <= 62);
-				a_Level >= 45 &&
+
-				a_Level <= 62
+			case cMonster::mtBat:
-			);
+				return (a_RelY <= 63) && (BlockLight <= 4) && (SkyLight <= 4) && (TargetBlock == E_BLOCK_AIR) && (!g_BlockTransparent[BlockAbove]);
-		}
+
-		else if (a_MobType == cMonster::mtBat)
+			case cMonster::mtChicken:
-		{
+			case cMonster::mtCow:
-			toReturn = a_Level <= 60; // MG TODO  : find a real rule
+			case cMonster::mtPig:
-		}
+			case cMonster::mtHorse:
-		else
+			case cMonster::mtSheep:
-		{
-			if (
-				a_BlockType == E_BLOCK_AIR &&
-				a_BlockType_above == E_BLOCK_AIR &&
-				! (g_BlockTransparent[a_BlockType_below])
-				)
 			{
-				if (a_MobType == cMonster::mtChicken || a_MobType == cMonster::mtPig || a_MobType == cMonster::mtCow || a_MobType == cMonster::mtSheep)
+				return (TargetBlock == E_BLOCK_AIR) && (BlockAbove == E_BLOCK_AIR) && (!g_BlockTransparent[BlockBelow]) &&
-				{
+						(BlockBelow == E_BLOCK_GRASS) && (SkyLight >= 9);
-					toReturn = (
-						a_BlockType_below == E_BLOCK_GRASS /*&& // MG TODO
-						a_LightLevel >= 9 */
-						);
-				}
-				else if (a_MobType == cMonster::mtOcelot)
-				{
-					toReturn = (
-						a_Level >= 62 &&
-						(
-							a_BlockType_below == E_BLOCK_GRASS ||
-							a_BlockType_below == E_BLOCK_LEAVES
-						) &&
-						m_Random.NextInt(3,a_Biome) != 0
-						);
-				}
-				else if (a_MobType == cMonster::mtCreeper || a_MobType == cMonster::mtSkeleton || a_MobType == cMonster::mtZombie || a_MobType == cMonster::mtSpider || a_MobType == cMonster::mtEnderman || a_MobType == cMonster::mtZombiePigman)
-				{
-					toReturn = true /*a_LightLevel <= 7 MG TODO*/;
-					/*if (a_SunLight) MG TODO 
-					{
-						if (m_Random.NextInt(2,a_Biome) != 0)
-						{
-							toReturn = false;
-						}
-					}*/
-				}
-				else if (a_MobType == cMonster::mtSlime)
-				{
-					toReturn = a_Level <= 40;
-					// MG TODO : much more complicated rules		
-				}
-				else if (a_MobType == cMonster::mtGhast)
-				{
-					toReturn = m_Random.NextInt(20,a_Biome) == 0;
-				}
-				else
-				{
-					LOGD("MG TODO : check I've got a Rule to write for type %d",a_MobType);
-					toReturn = true;
-				}
 			}
+				
+			case cMonster::mtOcelot:
+			{
+				return (TargetBlock == E_BLOCK_AIR) && (BlockAbove == E_BLOCK_AIR) &&
+						((BlockBelow == E_BLOCK_GRASS) || (BlockBelow == E_BLOCK_LEAVES)) && (a_RelY >= 62) && (m_Random.NextInt(3,a_Biome) != 0);
+			}
+			case cMonster::mtEnderman:
+			{
+				if (a_RelY < 250)
+				{
+					BLOCKTYPE BlockTop = a_Chunk->GetBlock(a_RelX, a_RelY + 2, a_RelZ);
+					if (BlockTop == E_BLOCK_AIR)
+					{
+						BlockTop = a_Chunk->GetBlock(a_RelX, a_RelY + 3, a_RelZ);
+						return  (TargetBlock == E_BLOCK_AIR) && (BlockAbove == E_BLOCK_AIR) && (BlockTop == E_BLOCK_AIR) && (!g_BlockTransparent[BlockBelow]) &&
+						(SkyLight <= 7) && (BlockLight <= 7);
+					}
+				}
+				break;
+			}
+			case cMonster::mtSpider:
+			{
+				bool CanSpawn = true;
+				bool HaveFloor = false;
+				for (int x = 0; x < 2; ++x)
+				{
+					for(int z = 0; z < 2; ++z)
+					{
+						CanSpawn = a_Chunk->UnboundedRelGetBlockType(a_RelX + x, a_RelY, a_RelZ + z, TargetBlock);
+						CanSpawn = CanSpawn && (TargetBlock == E_BLOCK_AIR);
+						if (!CanSpawn)
+						{
+							return false;
+						}
+						if (!HaveFloor)
+						{
+							a_Chunk->UnboundedRelGetBlockType(a_RelX + x, a_RelY - 1, a_RelZ + z, TargetBlock);
+							HaveFloor = HaveFloor || !g_BlockTransparent[TargetBlock];
+						}
+					}
+				}
+				return CanSpawn && HaveFloor && (SkyLight <= 7) && (BlockLight <= 7);
+
+			}
+			case cMonster::mtCreeper:
+			case cMonster::mtZombie:
+				return (TargetBlock == E_BLOCK_AIR) && (BlockAbove == E_BLOCK_AIR) && (!g_BlockTransparent[BlockBelow]) &&
+						(SkyLight <= 7) && (BlockLight <= 7) && (m_Random.NextInt(2,a_Biome) == 0);
+
+			case cMonster::mtSlime:
+				return (TargetBlock == E_BLOCK_AIR) && (BlockAbove == E_BLOCK_AIR) && (!g_BlockTransparent[BlockBelow]) &&
+						((a_RelY <= 40) || a_Biome == biSwampland);
+			case cMonster::mtGhast:
+			case cMonster::mtZombiePigman:
+				return (TargetBlock == E_BLOCK_AIR) && (BlockAbove == E_BLOCK_AIR) && (!g_BlockTransparent[BlockBelow]) &&
+						(m_Random.NextInt(20,a_Biome) == 0);
+			default:
+				LOGD("MG TODO : check I've got a Rule to write for type %d",a_MobType);
+				return false;
 		}
 	}
-	return toReturn;
+	return false;
 }
 
 
 
 
 
-cMonster* cMobSpawner::TryToSpawnHere(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, BLOCKTYPE a_BlockType_below, NIBBLETYPE a_BlockMeta_below, BLOCKTYPE a_BlockType_above, NIBBLETYPE a_BlockMeta_above, EMCSBiome a_Biome, int a_Level, int& a_MaxPackSize)
+cMonster* cMobSpawner::TryToSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, EMCSBiome a_Biome, int& a_MaxPackSize)
 {
 	cMonster* toReturn = NULL;
 	if (m_NewPack)
@@ -225,8 +242,10 @@ cMonster* cMobSpawner::TryToSpawnHere(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockM
 		m_NewPack = false;
 	}
 
+	// Make sure we are looking at the right chunk to spawn in
+	a_Chunk = a_Chunk->GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
 	
-	if (CanSpawnHere(m_MobType, a_BlockType, a_BlockMeta, a_BlockType_below, a_BlockMeta_below, a_BlockType_above, a_BlockMeta_above, a_Biome, a_Level))
+	if (CanSpawnHere(a_Chunk, a_RelX, a_RelY, a_RelZ, m_MobType, a_Biome))
 	{
 		cMonster * newMob = cMonster::NewMonsterFromType(m_MobType);
 		if (newMob)

source/MobSpawner.h

@@ -4,6 +4,7 @@
 #include <set>
 #include "BlockID.h"
 #include "ChunkDef.h"
+#include "Chunk.h"
 #include "FastRandom.h"
 #include "Mobs/Monster.h" //this is a side-effect of keeping Mobfamily inside Monster class. I'd prefer to keep both (Mobfamily and Monster) inside a "Monster" namespace MG TODO : do it
 
@@ -38,7 +39,7 @@ public :
 	// if this is the first of a Pack : determine the type of monster
 	// BlockType & BlockMeta are used to decide what kind of Mob can Spawn here
 	// MaxPackSize is set to the maximal size for a pack this type of mob
-	cMonster * TryToSpawnHere(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, BLOCKTYPE a_BlockType_below, NIBBLETYPE a_BlockMeta_below, BLOCKTYPE a_BlockType_above, NIBBLETYPE a_BlockMeta_above, EMCSBiome a_Biome, int a_Level, int& a_MaxPackSize);
+	cMonster * TryToSpawnHere(cChunk * a_Chunk, int A_RelX, int a_RelY, int a_RelZ, EMCSBiome a_Biome, int& a_MaxPackSize);
 
 	// mark the beginning of a new Pack
 	// all mobs of the same Pack are the same type
@@ -52,7 +53,7 @@ public :
 
 protected : 
 	// return true if specified type of mob can spawn on specified block
-	bool CanSpawnHere(cMonster::eType a_MobType, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, BLOCKTYPE a_BlockType_below, NIBBLETYPE a_BlockMeta_below, BLOCKTYPE a_BlockType_above, NIBBLETYPE a_BlockMeta_above, EMCSBiome a_Biome, int a_Level);
+	bool CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, cMonster::eType a_MobType, EMCSBiome a_Biome);
 
 	// return a random type that can spawn on specified biome.
 	// returns E_ENTITY_TYPE_DONOTUSE if none is possible

source/Mobs/Monster.cpp

@@ -609,9 +609,9 @@ int cMonster::GetSpawnDelay(cMonster::eFamily a_MobFamily)
 {
 	switch (a_MobFamily)
 	{
-		case mfHostile: return 1;
+		case mfHostile: return 40;
-		case mfPassive: return 400;
+		case mfPassive: return 40;
-		case mfAmbient: return 400;
+		case mfAmbient: return 40;
 		case mfWater:   return 400;
 	}
 	ASSERT(!"Unhandled mob family");

source/World.cpp

@@ -229,7 +229,8 @@ cWorld::cWorld(const AString & a_WorldName) :
 	m_RSList(0),
 	m_Weather(eWeather_Sunny),
 	m_WeatherInterval(24000),  // Guaranteed 1 day of sunshine at server start :)
-	m_TickThread(*this)
+	m_TickThread(*this),
+	m_SkyDarkness(0)
 {
 	LOGD("cWorld::cWorld(\"%s\")", a_WorldName.c_str());
 
@@ -608,6 +609,9 @@ void cWorld::Tick(float a_Dt)
 	m_WorldAge  = (Int64)(m_WorldAgeSecs  * 20.0);
 	m_TimeOfDay = (Int64)(m_TimeOfDaySecs * 20.0);
 
+	// Updates the sky darkness based on current time of day
+	UpdateSkyDarkness();
+
 	// Broadcast time update every 40 ticks (2 seconds)
 	if (m_LastTimeUpdate < m_WorldAge - 40)
 	{
@@ -2676,3 +2680,30 @@ void cWorld::cTaskSaveAllChunks::Run(cWorld & a_World)
 
 
 
+
+#define TIME_SUNSET 		12000
+#define TIME_NIGHT_START	13187
+#define TIME_NIGHT_END		22812
+#define TIME_SUNRISE		23999
+#define TIME_SPAWN_DIVIZOR	148
+
+
+
+
+
+void cWorld::UpdateSkyDarkness()
+{
+	int TempTime = m_TimeOfDay;
+	if (TempTime <= TIME_SUNSET)
+		m_SkyDarkness = 0;
+	else if (TempTime <= TIME_NIGHT_START)
+		m_SkyDarkness = (TIME_NIGHT_START - TempTime)/TIME_SPAWN_DIVIZOR;
+	else if (TempTime <= TIME_NIGHT_END)
+		m_SkyDarkness = 8;
+	else
+		m_SkyDarkness = (TIME_SUNRISE - TempTime)/TIME_SPAWN_DIVIZOR;
+}
+
+
+
+

source/World.h

@@ -592,6 +592,9 @@ public:
 	/// Appends all usernames starting with a_Text (case-insensitive) into Results
 	void TabCompleteUserName(const AString & a_Text, AStringVector & a_Results);
 
+	/// Get the current darkness level based on the time
+	NIBBLETYPE GetSkyDarkness() { return m_SkyDarkness; }
+
 private:
 
 	friend class cRoot;
@@ -636,6 +639,8 @@ private:
 	Int64  m_LastSave;          // The last WorldAge (in ticks) in which save-all was triggerred
 	std::map<cMonster::eFamily,Int64> m_LastSpawnMonster; // The last WorldAge (in ticks) in which a monster was spawned (for each megatype of monster) // MG TODO : find a way to optimize without creating unmaintenability (if mob IDs are becoming unrowed)
 
+	NIBBLETYPE m_SkyDarkness;
+
 	eGameMode m_GameMode;
 	bool m_bEnabledPVP;
 	bool m_IsDeepSnowEnabled;
@@ -727,6 +732,8 @@ private:
 	
 	/// Ticks all clients that are in this world
 	void TickClients(float a_Dt);
+
+	void UpdateSkyDarkness();
 	
 	/// Creates a new fluid simulator, loads its settings from the inifile (a_FluidName section)
 	cFluidSimulator * InitializeFluidSimulator(cIniFile & a_IniFile, const char * a_FluidName, BLOCKTYPE a_SimulateBlock, BLOCKTYPE a_StationaryBlock);