flewkey
/
cuberite-2a
1
0
Fork 0
Code Releases Activity

Moved all MobTypesManager functions to cMonster. 

This removes some of the memory leaks and is more logical in structure. Also the functions are exported to Lua.
This commit is contained in:
madmaxoft 2013-10-20 13:25:56 +02:00
parent 359918127b
commit 848d061de1
9 changed files with 352 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
VC2008/MCServer.vcproj
View File

@ -738,14 +738,6 @@
RelativePath="..\source\MobSpawner.h"
>
</File>
<File
RelativePath="..\source\MobTypesManager.cpp"
>
</File>
<File
RelativePath="..\source\MobTypesManager.h"
>
</File>
<File
RelativePath="..\source\MonsterConfig.cpp"
>

96
source/Bindings.cpp
View File

@ -1,6 +1,6 @@
/*
** Lua binding: AllToLua
** Generated automatically by tolua++-1.0.92 on 10/20/13 10:19:10.
** Generated automatically by tolua++-1.0.92 on 10/20/13 13:24:03.
*/
#ifndef __cplusplus
@ -29261,6 +29261,97 @@ static int tolua_AllToLua_cMonster_GetMobFamily00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: MobTypeToString of class cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_MobTypeToString00
static int tolua_AllToLua_cMonster_MobTypeToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cMonster",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cMonster::eType a_MobType = ((cMonster::eType) (int) tolua_tonumber(tolua_S,2,0));
{
AString tolua_ret = (AString) cMonster::MobTypeToString(a_MobType);
tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'MobTypeToString'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: StringToMobType of class cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_StringToMobType00
static int tolua_AllToLua_cMonster_StringToMobType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cMonster",0,&tolua_err) ||
!tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
const AString a_MobTypeName = ((const AString) tolua_tocppstring(tolua_S,2,0));
{
cMonster::eType tolua_ret = (cMonster::eType) cMonster::StringToMobType(a_MobTypeName);
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
tolua_pushcppstring(tolua_S,(const char*)a_MobTypeName);
}
}
return 2;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'StringToMobType'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: FamilyFromType of class cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_FamilyFromType00
static int tolua_AllToLua_cMonster_FamilyFromType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cMonster",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cMonster::eType a_MobType = ((cMonster::eType) (int) tolua_tonumber(tolua_S,2,0));
{
cMonster::eFamily tolua_ret = (cMonster::eFamily) cMonster::FamilyFromType(a_MobType);
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'FamilyFromType'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* Open function */
TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
{
@ -31353,6 +31444,9 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
tolua_constant(tolua_S,"mfMaxplusone",cMonster::mfMaxplusone);
tolua_function(tolua_S,"GetMobType",tolua_AllToLua_cMonster_GetMobType00);
tolua_function(tolua_S,"GetMobFamily",tolua_AllToLua_cMonster_GetMobFamily00);
tolua_function(tolua_S,"MobTypeToString",tolua_AllToLua_cMonster_MobTypeToString00);
tolua_function(tolua_S,"StringToMobType",tolua_AllToLua_cMonster_StringToMobType00);
tolua_function(tolua_S,"FamilyFromType",tolua_AllToLua_cMonster_FamilyFromType00);
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"cLineBlockTracer","cLineBlockTracer","",NULL);
tolua_beginmodule(tolua_S,"cLineBlockTracer");

2
source/Bindings.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: AllToLua
** Generated automatically by tolua++-1.0.92 on 10/20/13 10:19:10.
** Generated automatically by tolua++-1.0.92 on 10/20/13 13:24:04.
*/
/* Exported function */

6
source/MobSpawner.cpp
View File

@ -2,8 +2,6 @@
#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()
@ -57,7 +55,7 @@ cMobSpawner::cMobSpawner(cMonster::eFamily a_MonsterFamily,const std::set<cMonst
{
for (std::set<cMonster::eType>::const_iterator itr = a_AllowedTypes.begin(); itr != a_AllowedTypes.end(); itr++)
{
if (cMobTypesManager::FamilyFromType(*itr) == a_MonsterFamily)
if (cMonster::FamilyFromType(*itr) == a_MonsterFamily)
{
m_AllowedTypes.insert(*itr);
}
@ -256,7 +254,7 @@ cMonster* cMobSpawner::TryToSpawnHere(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockM
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);
cMonster * newMob = cMonster::NewMonsterFromType(m_MobType);
if (newMob)
{
m_Spawned.insert(newMob);

229
source/MobTypesManager.cpp
View File

@ -1,229 +0,0 @@
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
#include "MobTypesManager.h"
#include "MersenneTwister.h"
#include "Mobs/Monster.h"
#include "Mobs/IncludeAllMonsters.h"
#include "FastRandom.h"
/** Map for cMonster::eType <-> string
Needs to be alpha-sorted by the strings, because binary search is used in StringToMobType()
The strings need to be lowercase (for more efficient comparisons in StringToMobType())
*/
static const struct
{
cMonster::eType m_Type;
const char * m_lcName;
} g_MobTypeNames[] =
{
{cMonster::mtBat, "bat"},
{cMonster::mtBlaze, "blaze"},
{cMonster::mtCaveSpider, "cavespider"},
{cMonster::mtChicken, "chicken"},
{cMonster::mtCow, "cow"},
{cMonster::mtCreeper, "creeper"},
{cMonster::mtEnderman, "enderman"},
{cMonster::mtGhast, "ghast"},
{cMonster::mtHorse, "horse"},
{cMonster::mtMagmaCube, "magmacube"},
{cMonster::mtMooshroom, "mooshroom"},
{cMonster::mtOcelot, "ocelot"},
{cMonster::mtPig, "pig"},
{cMonster::mtSheep, "sheep"},
{cMonster::mtSilverfish, "silverfish"},
{cMonster::mtSkeleton, "skeleton"},
{cMonster::mtSlime, "slime"},
{cMonster::mtSpider, "spider"},
{cMonster::mtSquid, "squid"},
{cMonster::mtVillager, "villager"},
{cMonster::mtWitch, "witch"},
{cMonster::mtWolf, "wolf"},
{cMonster::mtZombie, "zombie"},
{cMonster::mtZombiePigman, "zombiepigman"},
} ;
cMonster * cMobTypesManager::NewMonsterFromType(cMonster::eType a_MobType, int a_Size)
{
cFastRandom Random;
cMonster * toReturn = NULL;
// unspecified size get rand[1,3] for Monsters that need size
switch (a_MobType)
{
case cMonster::mtMagmaCube:
case cMonster::mtSlime:
{
if (a_Size == -1)
{
a_Size = Random.NextInt(2, a_MobType) + 1;
}
if ((a_Size <= 0) || (a_Size >= 4))
{
ASSERT(!"Random for size was supposed to pick in [1..3] and picked outside");
a_Size = 1;
}
break;
}
default: break;
} // switch (a_MobType)
// Create the mob entity
switch (a_MobType)
{
case cMonster::mtMagmaCube: toReturn = new cMagmaCube(a_Size); break;
case cMonster::mtSlime: toReturn = new cSlime(a_Size); break;
case cMonster::mtBat: toReturn = new cBat(); break;
case cMonster::mtBlaze: toReturn = new cBlaze(); break;
case cMonster::mtCaveSpider: toReturn = new cCavespider(); break;
case cMonster::mtChicken: toReturn = new cChicken(); break;
case cMonster::mtCow: toReturn = new cCow(); break;
case cMonster::mtCreeper: toReturn = new cCreeper(); break;
case cMonster::mtEnderman: toReturn = new cEnderman(); break;
case cMonster::mtGhast: toReturn = new cGhast(); break;
// TODO:
// case cMonster::mtHorse: toReturn = new cHorse(); break;
case cMonster::mtMooshroom: toReturn = new cMooshroom(); break;
case cMonster::mtOcelot: toReturn = new cOcelot(); break;
case cMonster::mtPig: toReturn = new cPig(); break;
// TODO: Implement sheep color
case cMonster::mtSheep: toReturn = new cSheep(0); break;
case cMonster::mtSilverfish: toReturn = new cSilverfish(); break;
// TODO: Implement wither skeleton geration
case cMonster::mtSkeleton: toReturn = new cSkeleton(false); break;
case cMonster::mtSpider: toReturn = new cSpider(); break;
case cMonster::mtSquid: toReturn = new cSquid(); break;
case cMonster::mtVillager: toReturn = new cVillager(cVillager::vtFarmer); break;
case cMonster::mtWitch: toReturn = new cWitch(); break;
case cMonster::mtWolf: toReturn = new cWolf(); break;
case cMonster::mtZombie: toReturn = new cZombie(false); break;
case cMonster::mtZombiePigman: toReturn = new cZombiePigman(); break;
default:
{
ASSERT(!"Unhandled Mob type");
}
}
return toReturn;
}
AString cMobTypesManager::MobTypeToString(cMonster::eType a_MobType)
{
// Mob types aren't sorted, so we need to search linearly:
for (int i = 0; i < ARRAYCOUNT(g_MobTypeNames); i++)
{
if (g_MobTypeNames[i].m_Type == a_MobType)
{
return g_MobTypeNames[i].m_lcName;
}
}
// Not found:
return "";
}
cMonster::eType cMobTypesManager::StringToMobType(const AString & a_Name)
{
AString lcName(a_Name);
StrToLower(lcName);
// Binary-search for the lowercase name:
int lo = 0, hi = ARRAYCOUNT(g_MobTypeNames);
while (hi - lo > 1)
{
int mid = (lo + hi) / 2;
int res = strcmp(g_MobTypeNames[mid].m_lcName, lcName.c_str());
if (res == 0)
{
return g_MobTypeNames[mid].m_Type;
}
if (res < 0)
{
hi = mid;
}
else
{
lo = mid;
}
}
// Range has collapsed to at most two elements, compare each:
if (strcmp(g_MobTypeNames[lo].m_lcName, lcName.c_str()) == 0)
{
return g_MobTypeNames[lo].m_Type;
}
if ((lo != hi) && (strcmp(g_MobTypeNames[hi].m_lcName, lcName.c_str()) == 0))
{
return g_MobTypeNames[hi].m_Type;
}
// Not found:
return cMonster::mtInvalidType;
}
cMonster::eFamily cMobTypesManager::FamilyFromType(cMonster::eType a_Type)
{
static const struct
{
cMonster::eType m_Type;
cMonster::eFamily m_Family;
} TypeMap[] =
{
{cMonster::mtBat, cMonster::mfAmbient},
{cMonster::mtBlaze, cMonster::mfHostile},
{cMonster::mtCaveSpider, cMonster::mfHostile},
{cMonster::mtChicken, cMonster::mfPassive},
{cMonster::mtCow, cMonster::mfPassive},
{cMonster::mtCreeper, cMonster::mfHostile},
{cMonster::mtEnderman, cMonster::mfHostile},
{cMonster::mtGhast, cMonster::mfHostile},
{cMonster::mtHorse, cMonster::mfPassive},
{cMonster::mtMagmaCube, cMonster::mfHostile},
{cMonster::mtMooshroom, cMonster::mfHostile},
{cMonster::mtOcelot, cMonster::mfHostile},
{cMonster::mtPig, cMonster::mfPassive},
{cMonster::mtSheep, cMonster::mfPassive},
{cMonster::mtSilverfish, cMonster::mfHostile},
{cMonster::mtSkeleton, cMonster::mfHostile},
{cMonster::mtSlime, cMonster::mfHostile},
{cMonster::mtSpider, cMonster::mfHostile},
{cMonster::mtSquid, cMonster::mfWater},
{cMonster::mtVillager, cMonster::mfPassive},
{cMonster::mtWitch, cMonster::mfHostile},
{cMonster::mtWolf, cMonster::mfHostile},
{cMonster::mtZombie, cMonster::mfHostile},
{cMonster::mtZombiePigman, cMonster::mfHostile},
} ;
for (int i = 0; i < ARRAYCOUNT(TypeMap); i++)
{
if (TypeMap[i].m_Type == a_Type)
{
return TypeMap[i].m_Family;
}
}
return cMonster::mfMaxplusone;
}

41
source/MobTypesManager.h
View File

@ -1,41 +0,0 @@
#pragma once
#include "Mobs/Monster.h" // this is a side effect of declaring cMonster::eType inside cMonster MG TODO : make a namespace
// fwd:
class cFastRandom;
/**
This class aggregates static functions about mob types:
- create a mob from its type (as enum) (in that way it is a compiler-proxy for mobs)
- transform MobTypes from enums to string and vice versa
- return mob family from given type
*/
class cMobTypesManager
{
public:
static AString MobTypeToString(cMonster::eType a_MobType);
static cMonster::eType StringToMobType(const AString& a_MobTypeName);
static cMonster::eFamily FamilyFromType(cMonster::eType a_MobType);
/** create a new object of the specified mob.
a_MobType is the type of the mob to be created
a_Size is the size (for mobs with size)
if a_Size is let to -1 for entities that need size, size will be random
asserts and returns null if mob type is not specified
asserts if invalid size for mobs that need size
*/
static cMonster * NewMonsterFromType(cMonster::eType a_MobType, int a_Size = -1);
} ;

229
source/Mobs/Monster.cpp
View File

@ -1,7 +1,7 @@
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
#include "Monster.h"
#include "IncludeAllMonsters.h"
#include "../Root.h"
#include "../Server.h"
#include "../ClientHandle.h"
@ -9,7 +9,6 @@
#include "../Entities/Player.h"
#include "../Defines.h"
#include "../MonsterConfig.h"
#include "../MobTypesManager.h"
#include "../MersenneTwister.h"
#include "../Vector3f.h"
@ -17,14 +16,55 @@
#include "../Vector3d.h"
#include "../Tracer.h"
#include "../Chunk.h"
// #include "../../iniFile/iniFile.h"
#include "../FastRandom.h"
/** Map for eType <-> string
Needs to be alpha-sorted by the strings, because binary search is used in StringToMobType()
The strings need to be lowercase (for more efficient comparisons in StringToMobType())
*/
static const struct
{
cMonster::eType m_Type;
const char * m_lcName;
} g_MobTypeNames[] =
{
{cMonster::mtBat, "bat"},
{cMonster::mtBlaze, "blaze"},
{cMonster::mtCaveSpider, "cavespider"},
{cMonster::mtChicken, "chicken"},
{cMonster::mtCow, "cow"},
{cMonster::mtCreeper, "creeper"},
{cMonster::mtEnderman, "enderman"},
{cMonster::mtGhast, "ghast"},
{cMonster::mtHorse, "horse"},
{cMonster::mtMagmaCube, "magmacube"},
{cMonster::mtMooshroom, "mooshroom"},
{cMonster::mtOcelot, "ocelot"},
{cMonster::mtPig, "pig"},
{cMonster::mtSheep, "sheep"},
{cMonster::mtSilverfish, "silverfish"},
{cMonster::mtSkeleton, "skeleton"},
{cMonster::mtSlime, "slime"},
{cMonster::mtSpider, "spider"},
{cMonster::mtSquid, "squid"},
{cMonster::mtVillager, "villager"},
{cMonster::mtWitch, "witch"},
{cMonster::mtWolf, "wolf"},
{cMonster::mtZombie, "zombie"},
{cMonster::mtZombiePigman, "zombiepigman"},
} ;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cMonster:
cMonster::cMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height)
: super(etMonster, a_Width, a_Height)
, m_Target(NULL)
@ -467,6 +507,183 @@ void cMonster::SetSightDistance(float sd)
AString cMonster::MobTypeToString(cMonster::eType a_MobType)
{
// Mob types aren't sorted, so we need to search linearly:
for (int i = 0; i < ARRAYCOUNT(g_MobTypeNames); i++)
{
if (g_MobTypeNames[i].m_Type == a_MobType)
{
return g_MobTypeNames[i].m_lcName;
}
}
// Not found:
return "";
}
cMonster::eType cMonster::StringToMobType(const AString & a_Name)
{
AString lcName(a_Name);
StrToLower(lcName);
// Binary-search for the lowercase name:
int lo = 0, hi = ARRAYCOUNT(g_MobTypeNames);
while (hi - lo > 1)
{
int mid = (lo + hi) / 2;
int res = strcmp(g_MobTypeNames[mid].m_lcName, lcName.c_str());
if (res == 0)
{
return g_MobTypeNames[mid].m_Type;
}
if (res < 0)
{
hi = mid;
}
else
{
lo = mid;
}
}
// Range has collapsed to at most two elements, compare each:
if (strcmp(g_MobTypeNames[lo].m_lcName, lcName.c_str()) == 0)
{
return g_MobTypeNames[lo].m_Type;
}
if ((lo != hi) && (strcmp(g_MobTypeNames[hi].m_lcName, lcName.c_str()) == 0))
{
return g_MobTypeNames[hi].m_Type;
}
// Not found:
return mtInvalidType;
}
cMonster::eFamily cMonster::FamilyFromType(eType a_Type)
{
static const struct
{
eType m_Type;
eFamily m_Family;
} TypeMap[] =
{
{mtBat, mfAmbient},
{mtBlaze, mfHostile},
{mtCaveSpider, mfHostile},
{mtChicken, mfPassive},
{mtCow, mfPassive},
{mtCreeper, mfHostile},
{mtEnderman, mfHostile},
{mtGhast, mfHostile},
{mtHorse, mfPassive},
{mtMagmaCube, mfHostile},
{mtMooshroom, mfHostile},
{mtOcelot, mfHostile},
{mtPig, mfPassive},
{mtSheep, mfPassive},
{mtSilverfish, mfHostile},
{mtSkeleton, mfHostile},
{mtSlime, mfHostile},
{mtSpider, mfHostile},
{mtSquid, mfWater},
{mtVillager, mfPassive},
{mtWitch, mfHostile},
{mtWolf, mfHostile},
{mtZombie, mfHostile},
{mtZombiePigman, mfHostile},
} ;
for (int i = 0; i < ARRAYCOUNT(TypeMap); i++)
{
if (TypeMap[i].m_Type == a_Type)
{
return TypeMap[i].m_Family;
}
}
return mfMaxplusone;
}
cMonster * cMonster::NewMonsterFromType(cMonster::eType a_MobType, int a_Size)
{
cFastRandom Random;
cMonster * toReturn = NULL;
// unspecified size get rand[1,3] for Monsters that need size
switch (a_MobType)
{
case mtMagmaCube:
case mtSlime:
{
if (a_Size == -1)
{
a_Size = Random.NextInt(2, a_MobType) + 1;
}
if ((a_Size <= 0) || (a_Size >= 4))
{
ASSERT(!"Random for size was supposed to pick in [1..3] and picked outside");
a_Size = 1;
}
break;
}
default: break;
} // switch (a_MobType)
// Create the mob entity
switch (a_MobType)
{
case mtMagmaCube: toReturn = new cMagmaCube(a_Size); break;
case mtSlime: toReturn = new cSlime(a_Size); break;
case mtBat: toReturn = new cBat(); break;
case mtBlaze: toReturn = new cBlaze(); break;
case mtCaveSpider: toReturn = new cCavespider(); break;
case mtChicken: toReturn = new cChicken(); break;
case mtCow: toReturn = new cCow(); break;
case mtCreeper: toReturn = new cCreeper(); break;
case mtEnderman: toReturn = new cEnderman(); break;
case mtGhast: toReturn = new cGhast(); break;
// TODO:
// case cMonster::mtHorse: toReturn = new cHorse(); break;
case mtMooshroom: toReturn = new cMooshroom(); break;
case mtOcelot: toReturn = new cOcelot(); break;
case mtPig: toReturn = new cPig(); break;
// TODO: Implement sheep color
case mtSheep: toReturn = new cSheep(0); break;
case mtSilverfish: toReturn = new cSilverfish(); break;
// TODO: Implement wither skeleton geration
case mtSkeleton: toReturn = new cSkeleton(false); break;
case mtSpider: toReturn = new cSpider(); break;
case mtSquid: toReturn = new cSquid(); break;
case mtVillager: toReturn = new cVillager(cVillager::vtFarmer); break;
case mtWitch: toReturn = new cWitch(); break;
case mtWolf: toReturn = new cWolf(); break;
case mtZombie: toReturn = new cZombie(false); break;
case mtZombiePigman: toReturn = new cZombiePigman(); break;
default:
{
ASSERT(!"Unhandled Mob type");
}
}
return toReturn;
}
void cMonster::AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth)
{
MTRand r1;
@ -514,7 +731,7 @@ void cMonster::HandleDaylightBurning(cChunk & a_Chunk)
cMonster::eFamily cMonster::GetMobFamily(void) const
{
return cMobTypesManager::FamilyFromType(m_MobType);
return FamilyFromType(m_MobType);
}

26
source/Mobs/Monster.h
View File

@ -71,6 +71,9 @@ public:
// tolua_end
enum MState{ATTACKING, IDLE, CHASING, ESCAPING} m_EMState;
enum MPersonality{PASSIVE,AGGRESSIVE,COWARDLY} m_EMPersonality;
float m_SightDistance;
/** Creates the mob object.
@ -132,9 +135,28 @@ public:
virtual bool IsTame (void) const { return false; }
virtual bool IsSitting (void) const { return false; }
enum MState{ATTACKING, IDLE, CHASING, ESCAPING} m_EMState;
enum MPersonality{PASSIVE,AGGRESSIVE,COWARDLY} m_EMPersonality;
// tolua_begin
/// Translates MobType enum to a string
static AString MobTypeToString(eType a_MobType);
/// Translates MobType string to the enum
static eType StringToMobType(const AString & a_MobTypeName);
/// Returns the mob family based on the type
static eFamily FamilyFromType(eType a_MobType);
// tolua_end
/** Creates a new object of the specified mob.
a_MobType is the type of the mob to be created
a_Size is the size (for mobs with size)
if a_Size is let to -1 for entities that need size, size will be random
asserts and returns null if mob type is not specified
asserts if invalid size for mobs that need size
*/
static cMonster * NewMonsterFromType(eType a_MobType, int a_Size = -1);
protected:
cEntity * m_Target;

14
source/World.cpp
View File

@ -31,7 +31,6 @@
#include "Mobs/IncludeAllMonsters.h"
#include "MobCensus.h"
#include "MobSpawner.h"
#include "MobTypesManager.h"
#include "MersenneTwister.h"
#include "Generating/Trees.h"
@ -508,11 +507,11 @@ void cWorld::Start(void)
AStringVector SplitList = StringSplitAndTrim(AllMonsters, ",");
for (AStringVector::const_iterator itr = SplitList.begin(), end = SplitList.end(); itr != end; ++itr)
{
cMonster::eType ToAdd = cMobTypesManager::StringToMobType(*itr);
cMonster::eType ToAdd = cMonster::StringToMobType(*itr);
if (ToAdd != cMonster::mtInvalidType)
{
m_AllowedMobs.insert(ToAdd);
LOGD("Allowed mob: %s", cMobTypesManager::MobTypeToString(ToAdd).c_str()); // a bit reverse working, but very few ressources wasted
LOGD("Allowed mob: %s", itr->c_str());
}
else
{
@ -2524,20 +2523,21 @@ int cWorld::SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eTyp
{
cMonster * Monster = NULL;
int SlSize = GetTickRandomNumber(2) + 1; // 1 .. 3 - Slime
int ShColor = GetTickRandomNumber(15); // 0 .. 15 - Sheep
bool SkType = GetDimension() == dimNether ; // Skeleton
Monster = cMobTypesManager::NewMonsterFromType(a_MonsterType);
if (Monster)
Monster = cMonster::NewMonsterFromType(a_MonsterType);
if (Monster != NULL)
{
Monster->SetPosition(a_PosX, a_PosY, a_PosZ);
}
return SpawnMobFinalize(Monster);
}
int cWorld::SpawnMobFinalize(cMonster* a_Monster)
int cWorld::SpawnMobFinalize(cMonster * a_Monster)
{
if (!a_Monster)
return -1;