summaryrefslogtreecommitdiffstats
path: root/source
diff options
context:
space:
mode:
authormgueydan <gueydan.mathieuÃ@gmail.com>2013-09-08 01:21:43 +0200
committermgueydan <gueydan.mathieuÃ@gmail.com>2013-09-08 01:21:43 +0200
commitcaa54af54640d1c94c57bc84b6b1e4eb2e7a6f3c (patch)
treeda48273cd36e3095cefe782ae1e274dbe6745258 /source
parentAdding an Empty shell that would launch mob spawner - not called yet (diff)
downloadcuberite-caa54af54640d1c94c57bc84b6b1e4eb2e7a6f3c.tar
cuberite-caa54af54640d1c94c57bc84b6b1e4eb2e7a6f3c.tar.gz
cuberite-caa54af54640d1c94c57bc84b6b1e4eb2e7a6f3c.tar.bz2
cuberite-caa54af54640d1c94c57bc84b6b1e4eb2e7a6f3c.tar.lz
cuberite-caa54af54640d1c94c57bc84b6b1e4eb2e7a6f3c.tar.xz
cuberite-caa54af54640d1c94c57bc84b6b1e4eb2e7a6f3c.tar.zst
cuberite-caa54af54640d1c94c57bc84b6b1e4eb2e7a6f3c.zip
Diffstat (limited to '')
-rw-r--r--source/MobSpawner.cpp277
-rw-r--r--source/MobSpawner.h50
-rw-r--r--source/MobTypesManager.cpp50
-rw-r--r--source/MobTypesManager.h11
-rw-r--r--source/Mobs/Monster.h5
5 files changed, 384 insertions, 9 deletions
diff --git a/source/MobSpawner.cpp b/source/MobSpawner.cpp
new file mode 100644
index 000000000..19e3739cd
--- /dev/null
+++ b/source/MobSpawner.cpp
@@ -0,0 +1,277 @@
+
+#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
+
+#include "MobSpawner.h"
+#include "MobTypesManager.h"
+#include "Mobs/Monster.h"
+#include "Mobs/IncludeAllMonsters.h"
+
+
+cMobSpawner::tMobTypes& cMobSpawner::m_MobTypes()
+{
+ static tMobTypes* value = new tMobTypes(initMobTypesBeforeCx11());
+ return *value;
+}
+
+cMobSpawner::tMobTypes cMobSpawner::initMobTypesBeforeCx11()
+{
+ std::set<cMonster::eType> toReturn;
+ toReturn.insert(cMonster::mtCreeper);
+ toReturn.insert(cMonster::mtSkeleton);
+ toReturn.insert(cMonster::mtSpider);
+ toReturn.insert(cMonster::mtGiant);
+ toReturn.insert(cMonster::mtZombie);
+ toReturn.insert(cMonster::mtSlime);
+ toReturn.insert(cMonster::mtGhast);
+ toReturn.insert(cMonster::mtZombiePigman);
+ toReturn.insert(cMonster::mtEnderman);
+ toReturn.insert(cMonster::mtCaveSpider);
+ toReturn.insert(cMonster::mtSilverfish);
+ toReturn.insert(cMonster::mtBlaze);
+ toReturn.insert(cMonster::mtMagmaCube);
+ toReturn.insert(cMonster::mtEnderDragon);
+ toReturn.insert(cMonster::mtWither);
+ toReturn.insert(cMonster::mtBat);
+ toReturn.insert(cMonster::mtWitch);
+ toReturn.insert(cMonster::mtPig);
+ toReturn.insert(cMonster::mtSheep);
+ toReturn.insert(cMonster::mtCow);
+ toReturn.insert(cMonster::mtChicken);
+ toReturn.insert(cMonster::mtSquid);
+ toReturn.insert(cMonster::mtWolf);
+ toReturn.insert(cMonster::mtMooshroom);
+ toReturn.insert(cMonster::mtSnowGolem);
+ toReturn.insert(cMonster::mtOcelot);
+ toReturn.insert(cMonster::mtIronGolem);
+ toReturn.insert(cMonster::mtVillager);
+ return toReturn;
+}
+
+
+cMobSpawner::cMobSpawner(cMonster::eFamily a_MonsterFamily,const std::set<cMonster::eType>& a_AllowedTypes) :
+ m_MonsterFamily(a_MonsterFamily),
+ m_NewPack(true),
+ m_MobType(cMonster::mtInvalidType)
+{
+ for (std::set<cMonster::eType>::const_iterator itr = a_AllowedTypes.begin(); itr != a_AllowedTypes.end(); itr++)
+ {
+ if (cMobTypesManager::getFamilyFromType(*itr) == a_MonsterFamily)
+ {
+ m_AllowedTypes.insert(*itr);
+ }
+ }
+}
+
+bool cMobSpawner::CheckPackCenter(BLOCKTYPE a_BlockType)
+{
+ // Packs of non-water mobs can only be centered on an air block
+ // Packs of water mobs can only be centered on a water block
+ if (m_MonsterFamily == cMonster::mfWater)
+ {
+ return IsBlockWater(a_BlockType);
+ }
+ else
+ {
+ return a_BlockType == E_BLOCK_AIR;
+ }
+}
+
+void cMobSpawner::addIfAllowed(cMonster::eType toAdd, std::set<cMonster::eType>& toAddIn)
+{
+ std::set<cMonster::eType>::iterator itr = m_AllowedTypes.find(toAdd);
+ if (itr != m_AllowedTypes.end())
+ {
+ toAddIn.insert(toAdd);
+ }
+}
+
+cMonster::eType cMobSpawner::ChooseMobType(EMCSBiome a_Biome)
+{
+ std::set<cMonster::eType> allowedMobs;
+
+ if (a_Biome == biMushroomIsland || a_Biome == biMushroomShore)
+ {
+ addIfAllowed(cMonster::mtMooshroom, allowedMobs);
+ }
+ else if (a_Biome == biNether)
+ {
+ addIfAllowed(cMonster::mtGhast, allowedMobs);
+ addIfAllowed(cMonster::mtZombiePigman, allowedMobs);
+ addIfAllowed(cMonster::mtMagmaCube, allowedMobs);
+ }
+ /*else if (a_Biome == biEnder) MG TODO : figure out what are the biomes of the ender
+ {
+ addIfAllowed(cMonster::mtEnderman, allowedMobs);
+ }*/
+ else
+ {
+ addIfAllowed(cMonster::mtBat, allowedMobs);
+ addIfAllowed(cMonster::mtSpider, allowedMobs);
+ addIfAllowed(cMonster::mtZombie, allowedMobs);
+ addIfAllowed(cMonster::mtSkeleton, allowedMobs);
+ addIfAllowed(cMonster::mtCreeper, allowedMobs);
+ addIfAllowed(cMonster::mtSquid, allowedMobs);
+
+ if (a_Biome != biDesert && a_Biome != biBeach && a_Biome != biOcean)
+ {
+ addIfAllowed(cMonster::mtSheep, allowedMobs);
+ addIfAllowed(cMonster::mtPig, allowedMobs);
+ addIfAllowed(cMonster::mtCow, allowedMobs);
+ addIfAllowed(cMonster::mtChicken, allowedMobs);
+ addIfAllowed(cMonster::mtEnderman, allowedMobs);
+ addIfAllowed(cMonster::mtSlime, allowedMobs); // MG TODO : much more complicated rule
+
+ if (a_Biome == biForest || a_Biome == biForestHills || a_Biome == biTaiga || a_Biome == biTaigaHills)
+ {
+ addIfAllowed(cMonster::mtWolf, allowedMobs);
+ }
+ else if (a_Biome == biJungle || a_Biome == biJungleHills)
+ {
+ addIfAllowed(cMonster::mtOcelot, allowedMobs);
+ }
+ }
+ }
+
+ int allowedMobsSize = allowedMobs.size();
+ if (allowedMobsSize > 0)
+ {
+ std::set<cMonster::eType>::iterator itr = allowedMobs.begin();
+ int iRandom = m_Random.NextInt(allowedMobsSize,a_Biome);
+
+ for(int i = 0; i < iRandom; i++)
+ {
+ itr++;
+ }
+
+ return *itr;
+ }
+ return cMonster::mtInvalidType;
+}
+
+
+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 toReturn = false;
+ std::set<cMonster::eType>::iterator itr = m_AllowedTypes.find(a_MobType);
+ if (itr != m_AllowedTypes.end())
+ {
+ // MG TODO : find a nicer paging
+ if (a_MobType == cMonster::mtSquid)
+ {
+ toReturn = (
+ IsBlockLiquid(a_BlockType) &&
+ a_Level >= 45 &&
+ a_Level <= 62
+ );
+ }
+ else if (a_MobType == cMonster::mtBat)
+ {
+ toReturn = a_Level <= 60; // MG TODO : find a real rule
+ }
+ else
+ {
+ 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)
+ {
+ LOGD("Trying to spawn an animal");
+ 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;
+ }
+ }
+ }
+ }
+ return toReturn;
+}
+
+
+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* toReturn = NULL;
+ if (m_NewPack)
+ {
+ m_MobType = ChooseMobType(a_Biome);
+ if (m_MobType == cMonster::mtInvalidType)
+ {
+ return toReturn;
+ }
+ if (m_MobType == cMonster::mtWolf)
+ {
+ a_MaxPackSize = 8;
+ }
+ else if (m_MobType == cMonster::mtGhast)
+ {
+ a_MaxPackSize = 1;
+ }
+ m_NewPack = false;
+ }
+
+
+ if (CanSpawnHere(m_MobType, a_BlockType, a_BlockMeta, a_BlockType_below, a_BlockMeta_below, a_BlockType_above, a_BlockMeta_above, a_Biome, a_Level))
+ {
+ cMonster* newMob = cMobTypesManager::NewMonsterFromType(m_MobType);
+ if (newMob)
+ {
+ m_Spawned.insert(newMob);
+ }
+ toReturn = newMob;
+ }
+ return toReturn;
+}
+
+void cMobSpawner::NewPack()
+{
+ m_NewPack = true;
+}
+
+cMobSpawner::tSpawnedContainer& cMobSpawner::getSpawned()
+{
+ return m_Spawned;
+}
+
+bool cMobSpawner::CanSpawnSomething()
+{
+ return m_AllowedTypes.size() > 0;
+}
diff --git a/source/MobSpawner.h b/source/MobSpawner.h
index 7498c567d..bb9e95172 100644
--- a/source/MobSpawner.h
+++ b/source/MobSpawner.h
@@ -8,7 +8,6 @@
#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
class cChunk;
-class cEntity;
// This class is used to determine wich monster can be spawned on wich place
@@ -18,11 +17,56 @@ class cMobSpawner
{
public :
// constructor
- // a_MobFamily is the mega type of mobs that this spawner will spawn
+ // a_MobFamily is the Family of mobs that this spawner will spawn
// a_AllowedTypes is the set of types allowed for mobs it will spawn. Empty set
// would result in no spawn at all
- // Allowed mobs thah are not of the right Megatype will not be include (no warning)
+ // Allowed mobs thah are not of the right Family will not be include (no warning)
cMobSpawner(cMonster::eFamily MobFamily, const std::set<cMonster::eType>& a_AllowedTypes);
+ // Check if specified block can be a Pack center for this spawner
+ bool CheckPackCenter(BLOCKTYPE a_BlockType);
+
+ // Try to create a monster here
+ // if this is the first of a Pack : determine the type of monster
+ // BlockType & BlockMeta are use to know 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);
+
+ // mark the beginning of a new Pack
+ // all mobs of the same Pack are the same type
+ void NewPack();
+
+ // return true if there is at least one allowed type
+ bool CanSpawnSomething();
+
+ typedef const std::set<cMonster*> tSpawnedContainer;
+ tSpawnedContainer& getSpawned();
+
+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);
+
+ // return a random type that can spawn on specified biome.
+ // returns E_ENTITY_TYPE_DONOTUSE if none is possible
+ cMonster::eType ChooseMobType(EMCSBiome a_Biome);
+
+ // add toAdd inside toAddIn, if toAdd is in m_AllowedTypes
+ void addIfAllowed(cMonster::eType toAdd, std::set<cMonster::eType>& toAddIn);
+
+protected :
+ cMonster::eFamily m_MonsterFamily;
+ std::set<cMonster::eType> m_AllowedTypes;
+ bool m_NewPack;
+ cMonster::eType m_MobType;
+ std::set<cMonster*> m_Spawned;
+ cFastRandom m_Random;
+
+public :
+ typedef const std::set<cMonster::eType> tMobTypes; // MG TODO : maybe relocate all those statics set/maps in the same place ?
+ static tMobTypes& m_MobTypes();
+
+protected :
+ static tMobTypes initMobTypesBeforeCx11();
+
};
diff --git a/source/MobTypesManager.cpp b/source/MobTypesManager.cpp
index d8606e619..0c13e5aea 100644
--- a/source/MobTypesManager.cpp
+++ b/source/MobTypesManager.cpp
@@ -44,6 +44,43 @@ cMobTypesManager::tMobTypes2Names cMobTypesManager::MobTypes2NamesInitializerBef
return toReturn;
}
+cMobTypesManager::tMobType2Family& cMobTypesManager::m_MobsType2Family()
+{
+ static std::map<cMonster::eType,cMonster::eFamily>* value = new std::map<cMonster::eType,cMonster::eFamily>(MobType2FamilyInitializerBeforeCx11());
+ return *value;
+}
+
+cMobTypesManager::tMobType2Family cMobTypesManager::MobType2FamilyInitializerBeforeCx11()
+{
+ std::map<cMonster::eType,cMonster::eFamily> toReturn;
+ typedef std::map<cMonster::eType,cMonster::eFamily>::value_type ValueType;
+ toReturn.insert(ValueType(cMonster::mtBat,cMonster::mfAmbient));
+ toReturn.insert(ValueType(cMonster::mtSquid,cMonster::mfWater));
+ toReturn.insert(ValueType(cMonster::mtCow,cMonster::mfPassive));
+ toReturn.insert(ValueType(cMonster::mtPig,cMonster::mfPassive));
+ toReturn.insert(ValueType(cMonster::mtSheep,cMonster::mfPassive));
+ toReturn.insert(ValueType(cMonster::mtChicken,cMonster::mfPassive));
+ toReturn.insert(ValueType(cMonster::mtVillager,cMonster::mfPassive));
+ toReturn.insert(ValueType(cMonster::mtMagmaCube,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtSlime,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtBlaze,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtCaveSpider,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtCreeper,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtEnderman,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtGhast,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtMooshroom,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtOcelot,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtSilverfish,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtSkeleton,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtSpider,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtWitch,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtWolf,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtZombie,cMonster::mfHostile));
+ toReturn.insert(ValueType(cMonster::mtZombiePigman,cMonster::mfHostile));
+
+ return toReturn;
+}
+
cFastRandom& cMobTypesManager::m_Random()
{
@@ -126,5 +163,16 @@ cMonster::eType cMobTypesManager::fromStringToMobType(const std::string& a_Name)
return itr->first;
}
}
- throw new NotAMonsterException();
+ return cMonster::mtInvalidType;
+}
+
+cMonster::eFamily cMobTypesManager::getFamilyFromType(cMonster::eType a_Type)
+{
+ cMonster::eFamily toReturn = cMonster::mfMaxplusone;
+ std::map<cMonster::eType,cMonster::eFamily>::const_iterator itr = m_MobsType2Family().find(a_Type);
+ if (itr != m_MobsType2Family().end())
+ {
+ toReturn = itr->second;
+ }
+ return toReturn;
}
diff --git a/source/MobTypesManager.h b/source/MobTypesManager.h
index 0e628899e..a1b2dfddc 100644
--- a/source/MobTypesManager.h
+++ b/source/MobTypesManager.h
@@ -10,20 +10,23 @@ class cFastRandom;
// functionnalities are (in the first version) :
// - create a mob from its type (as enum) (in that way it is a compiler-proxy for mobs)
// - can transform MobTypes from enums to string and reciprocal
+// - return mob family from providen type
class cMobTypesManager
{
public:
static const std::string& fromMobTypeToString(cMonster::eType a_MobType);
- static cMonster::eType fromStringToMobType(const std::string&);
-
-public:
- class NotAMonsterException : public std::exception {}; //MG TODO : check if this is this project way to do it
+ static cMonster::eType fromStringToMobType(const std::string& a_MobTypeName);
+ static cMonster::eFamily getFamilyFromType(cMonster::eType a_MobType);
protected :
typedef const std::map<cMonster::eType,std::string> tMobTypes2Names;
static tMobTypes2Names& m_MobsTypes2Names();
static tMobTypes2Names MobTypes2NamesInitializerBeforeCx11();
+ typedef const std::map<cMonster::eType,cMonster::eFamily> tMobType2Family; //MG TODO : this is redundancy with cMonster::getFamily() methods. But almost all the management of MobType is redundancy in this project. Maybe is it optimization, or just historical TODO : understand and do something about it.
+ static tMobType2Family& m_MobsType2Family();
+ static tMobType2Family MobType2FamilyInitializerBeforeCx11();
+
static cFastRandom& m_Random();
public :
diff --git a/source/Mobs/Monster.h b/source/Mobs/Monster.h
index 594914ca0..ef7904e8e 100644
--- a/source/Mobs/Monster.h
+++ b/source/Mobs/Monster.h
@@ -54,6 +54,8 @@ public:
mtOcelot = E_META_SPAWN_EGG_OCELOT,
mtIronGolem = E_META_SPAWN_EGG_IRON_GOLEM,
mtVillager = E_META_SPAWN_EGG_VILLAGER,
+
+ mtInvalidType, // MG TODO : be sure this is the way we do in this project. (needed inside cMobSpawner::ChooscMonster for instance if nothing can be spawned)
} ;
enum eFamily
@@ -62,7 +64,8 @@ public:
mfPassive = 1, // Cows, Pigs
mfAmbient = 2, // Bats
mfWater = 3, // Squid
- mfMaxplusone = 4, // Nothing
+
+ mfMaxplusone, // Nothing. Be sure this is the last and the others are in order
} ;
// tolua_end