shared_mutex replace boost

Laserlicht · Laserlicht · commit 4e73f7d90ff1 · 2025-02-28T16:01:11.000+01:00
diff --git a/AI/Nullkiller/Pathfinding/Actors.h b/AI/Nullkiller/Pathfinding/Actors.h
@@ -93,7 +93,7 @@ class HeroExchangeMap
 	const HeroActor * actor;
 	std::map<const ChainActor *, HeroActor *> exchangeMap;
 	const Nullkiller * ai;
-	boost::shared_mutex sync;
+	std::shared_mutex sync;
 
 public:
 	HeroExchangeMap(const HeroActor * actor, const Nullkiller * ai);
diff --git a/include/vcmi/events/SubscriptionRegistry.h b/include/vcmi/events/SubscriptionRegistry.h
@@ -36,7 +36,7 @@ class SubscriptionRegistry : public boost::noncopyable
 
 	std::unique_ptr<EventSubscription> subscribeBefore(BusTag tag, PreHandler && handler)
 	{
-		std::unique_lock<boost::shared_mutex> lock(mutex);
+		std::unique_lock<std::shared_mutex> lock(mutex);
 
 		auto storage = std::make_shared<PreHandlerStorage>(std::move(handler));
 		preHandlers[tag].push_back(storage);
@@ -45,7 +45,7 @@ class SubscriptionRegistry : public boost::noncopyable
 
 	std::unique_ptr<EventSubscription> subscribeAfter(BusTag tag, PostHandler && handler)
 	{
-		std::unique_lock<boost::shared_mutex> lock(mutex);
+		std::unique_lock<std::shared_mutex> lock(mutex);
 
 		auto storage = std::make_shared<PostHandlerStorage>(std::move(handler));
 		postHandlers[tag].push_back(storage);
@@ -54,7 +54,7 @@ class SubscriptionRegistry : public boost::noncopyable
 
 	void executeEvent(const EventBus * bus, E & event, const ExecHandler & execHandler)
 	{
-		std::shared_lock<boost::shared_mutex> lock(mutex);
+		std::shared_lock<std::shared_mutex> lock(mutex);
 		{
 			auto it = preHandlers.find(bus);
 
@@ -141,15 +141,15 @@ class SubscriptionRegistry : public boost::noncopyable
 		std::shared_ptr<PostHandlerStorage> handler;
 	};
 
-	boost::shared_mutex mutex;
+	std::shared_mutex mutex;
 
 	std::map<BusTag, std::vector<std::shared_ptr<PreHandlerStorage>>> preHandlers;
 	std::map<BusTag, std::vector<std::shared_ptr<PostHandlerStorage>>> postHandlers;
 
 	template <typename T>
 	void unsubscribe(BusTag tag, T what, std::map<BusTag, std::vector<T>> & from)
 	{
-		std::unique_lock<boost::shared_mutex> lock(mutex);
+		std::unique_lock<std::shared_mutex> lock(mutex);
 
 		auto it = from.find(tag);
 
diff --git a/lib/CGameInfoCallback.cpp b/lib/CGameInfoCallback.cpp
@@ -185,7 +185,7 @@ const IMarket * CGameInfoCallback::getMarket(ObjectInstanceID objid) const
 
 void CGameInfoCallback::fillUpgradeInfo(const CArmedInstance *obj, SlotID stackPos, UpgradeInfo & out) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	ERROR_RET_IF(!canGetFullInfo(obj), "Cannot get info about not owned object!");
 	ERROR_RET_IF(!obj->hasStackAtSlot(stackPos), "There is no such stack!");
 	gs->fillUpgradeInfo(obj, stackPos, out);
@@ -194,7 +194,7 @@ void CGameInfoCallback::fillUpgradeInfo(const CArmedInstance *obj, SlotID stackP
 
 const StartInfo * CGameInfoCallback::getStartInfo(bool beforeRandomization) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	if(beforeRandomization)
 		return gs->initialOpts;
 	else
@@ -203,7 +203,7 @@ const StartInfo * CGameInfoCallback::getStartInfo(bool beforeRandomization) cons
 
 int32_t CGameInfoCallback::getSpellCost(const spells::Spell * sp, const CGHeroInstance * caster) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	ERROR_RET_VAL_IF(!canGetFullInfo(caster), "Cannot get info about caster!", -1);
 	//if there is a battle
 	auto casterBattle = gs->getBattle(caster->getOwner());
@@ -217,7 +217,7 @@ int32_t CGameInfoCallback::getSpellCost(const spells::Spell * sp, const CGHeroIn
 
 int64_t CGameInfoCallback::estimateSpellDamage(const CSpell * sp, const CGHeroInstance * hero) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 
 	ERROR_RET_VAL_IF(hero && !canGetFullInfo(hero), "Cannot get info about caster!", -1);
 
@@ -229,7 +229,7 @@ int64_t CGameInfoCallback::estimateSpellDamage(const CSpell * sp, const CGHeroIn
 
 void CGameInfoCallback::getThievesGuildInfo(SThievesGuildInfo & thi, const CGObjectInstance * obj)
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	ERROR_RET_IF(!obj, "No guild object!");
 	ERROR_RET_IF(obj->ID == Obj::TOWN && !canGetFullInfo(obj), "Cannot get info about town guild object!");
 	//TODO: advmap object -> check if they're visited by our hero
@@ -419,13 +419,13 @@ bool CGameInfoCallback::getHeroInfo(const CGObjectInstance * hero, InfoAboutHero
 
 int CGameInfoCallback::getDate(Date mode) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	return gs->getDate(mode);
 }
 
 bool CGameInfoCallback::isVisible(int3 pos, const std::optional<PlayerColor> & Player) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	return gs->isVisible(pos, Player);
 }
 
@@ -445,7 +445,7 @@ bool CGameInfoCallback::isVisible(const CGObjectInstance *obj) const
 }
 // const CCreatureSet* CInfoCallback::getGarrison(const CGObjectInstance *obj) const
 // {
-// 	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+// 	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 // 	if()
 // 	const CArmedInstance *armi = dynamic_cast<const CArmedInstance*>(obj);
 // 	if(!armi)
@@ -754,14 +754,14 @@ CGameInfoCallback::CGameInfoCallback(CGameState * GS):
 
 int CPlayerSpecificInfoCallback::howManyTowns() const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);
 	return CGameInfoCallback::howManyTowns(*getPlayerID());
 }
 
 std::vector < const CGTownInstance *> CPlayerSpecificInfoCallback::getTownsInfo(bool onlyOur) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	auto ret = std::vector < const CGTownInstance *>();
 	for(const auto & i : gs->players)
 	{
@@ -777,7 +777,7 @@ std::vector < const CGTownInstance *> CPlayerSpecificInfoCallback::getTownsInfo(
 }
 std::vector < const CGHeroInstance *> CPlayerSpecificInfoCallback::getHeroesInfo(bool onlyOur) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	std::vector < const CGHeroInstance *> ret;
 	for(auto hero : gs->map->heroesOnMap)
 	{
@@ -840,7 +840,7 @@ std::vector <QuestInfo> CPlayerSpecificInfoCallback::getMyQuests() const
 
 int CPlayerSpecificInfoCallback::howManyHeroes(bool includeGarrisoned) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);
 	return getHeroCount(*getPlayerID(), includeGarrisoned);
 }
@@ -872,14 +872,14 @@ const CGTownInstance* CPlayerSpecificInfoCallback::getTownBySerial(int serialId)
 
 int CPlayerSpecificInfoCallback::getResourceAmount(GameResID type) const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);
 	return getResource(*getPlayerID(), type);
 }
 
 TResources CPlayerSpecificInfoCallback::getResourceAmount() const
 {
-	//std::shared_lock<boost::shared_mutex> lock(*gs->mx);
+	//std::shared_lock<std::shared_mutex> lock(*gs->mx);
 	ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", TResources());
 	return gs->players[*getPlayerID()].resources;
 }
diff --git a/lib/UnlockGuard.h b/lib/UnlockGuard.h
@@ -114,7 +114,7 @@ namespace vstd
 			: unlock_guard<Mutex, detail::unlock_shared_policy<Mutex> >();
 	}
 
-	using unlock_shared_guard = unlock_guard<boost::shared_mutex, detail::unlock_shared_policy<boost::shared_mutex>>;
+	using unlock_shared_guard = unlock_guard<std::shared_mutex, detail::unlock_shared_policy<std::shared_mutex>>;
 }
 
 VCMI_LIB_NAMESPACE_END
diff --git a/lib/gameState/CGameState.cpp b/lib/gameState/CGameState.cpp
@@ -58,7 +58,7 @@
 
 VCMI_LIB_NAMESPACE_BEGIN
 
-boost::shared_mutex CGameState::mutex;
+std::shared_mutex CGameState::mutex;
 
 HeroTypeID CGameState::pickNextHeroType(const PlayerColor & owner)
 {
diff --git a/lib/gameState/CGameState.h b/lib/gameState/CGameState.h
@@ -82,7 +82,7 @@ class DLL_LINKAGE CGameState : public CNonConstInfoCallback, public Serializeabl
 
 	StatisticDataSet statistic;
 
-	static boost::shared_mutex mutex;
+	static std::shared_mutex mutex;
 
 	void updateEntity(Metatype metatype, int32_t index, const JsonNode & data) override;
 
diff --git a/lib/rmg/modificators/Modificator.h b/lib/rmg/modificators/Modificator.h
@@ -64,7 +64,7 @@ class Modificator
 	
 	mutable std::recursive_mutex externalAccessMutex; //Used to communicate between Modificators
 	using RecursiveLock = std::unique_lock<std::recursive_mutex>;
-	using Lock = std::unique_lock<boost::shared_mutex>;
+	using Lock = std::unique_lock<std::shared_mutex>;
 
 private:
 	virtual void process() = 0;
@@ -73,7 +73,7 @@ class Modificator
 
 	std::list<Modificator*> preceeders; //must be ordered container
 
-	mutable boost::shared_mutex mx; //Used only for task scheduling
+	mutable std::shared_mutex mx; //Used only for task scheduling
 
 	void dump();
 };
diff --git a/lib/rmg/threadpool/BlockingQueue.h b/lib/rmg/threadpool/BlockingQueue.h
@@ -19,8 +19,8 @@ VCMI_LIB_NAMESPACE_BEGIN
 template <typename T>
 class DLL_LINKAGE BlockingQueue : protected std::queue<T>
 {
-	using WriteLock = std::unique_lock<boost::shared_mutex>;
-	using Readlock = std::shared_lock<boost::shared_mutex>;
+	using WriteLock = std::unique_lock<std::shared_mutex>;
+	using Readlock = std::shared_lock<std::shared_mutex>;
 
 public:
 	BlockingQueue() = default;
@@ -85,7 +85,7 @@ class DLL_LINKAGE BlockingQueue : protected std::queue<T>
 	}
 
 private:
-	mutable boost::shared_mutex mx;
+	mutable std::shared_mutex mx;
 };
 
 VCMI_LIB_NAMESPACE_END
diff --git a/lib/rmg/threadpool/MapProxy.h b/lib/rmg/threadpool/MapProxy.h
@@ -33,8 +33,8 @@ class MapProxy
 	void drawRoads(vstd::RNG & generator, std::vector<int3> & tiles, RoadId roadType);
 
 private:
-	mutable boost::shared_mutex mx;
-	using Lock = std::unique_lock<boost::shared_mutex>;
+	mutable std::shared_mutex mx;
+	using Lock = std::unique_lock<std::shared_mutex>;
 
 	RmgMap & map;
 };
diff --git a/lib/rmg/threadpool/ThreadPool.h b/lib/rmg/threadpool/ThreadPool.h
@@ -24,8 +24,8 @@ typedef std::optional<TRMGfunction> TRMGJob;
 class DLL_LINKAGE ThreadPool
 {
 private:
-	using Lock = std::unique_lock<boost::shared_mutex>;
-	mutable boost::shared_mutex mx;
+	using Lock = std::unique_lock<std::shared_mutex>;
+	mutable std::shared_mutex mx;
 	mutable std::condition_variable_any cv;
 	mutable boost::once_flag once;
 

Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ const IMarket * CGameInfoCallback::getMarket(ObjectInstanceID objid) const`
`185`	`185`
`186`	`186`	`void CGameInfoCallback::fillUpgradeInfo(const CArmedInstance *obj, SlotID stackPos, UpgradeInfo & out) const`
`187`	`187`	`{`
`188`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`188`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`189`	`189`	`ERROR_RET_IF(!canGetFullInfo(obj), "Cannot get info about not owned object!");`
`190`	`190`	`ERROR_RET_IF(!obj->hasStackAtSlot(stackPos), "There is no such stack!");`
`191`	`191`	`gs->fillUpgradeInfo(obj, stackPos, out);`
`@@ -194,7 +194,7 @@ void CGameInfoCallback::fillUpgradeInfo(const CArmedInstance *obj, SlotID stackP`
`194`	`194`
`195`	`195`	`const StartInfo * CGameInfoCallback::getStartInfo(bool beforeRandomization) const`
`196`	`196`	`{`
`197`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`197`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`198`	`198`	`if(beforeRandomization)`
`199`	`199`	`return gs->initialOpts;`
`200`	`200`	`else`
`@@ -203,7 +203,7 @@ const StartInfo * CGameInfoCallback::getStartInfo(bool beforeRandomization) cons`
`203`	`203`
`204`	`204`	`int32_t CGameInfoCallback::getSpellCost(const spells::Spell * sp, const CGHeroInstance * caster) const`
`205`	`205`	`{`
`206`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`206`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`207`	`207`	`ERROR_RET_VAL_IF(!canGetFullInfo(caster), "Cannot get info about caster!", -1);`
`208`	`208`	`//if there is a battle`
`209`	`209`	`auto casterBattle = gs->getBattle(caster->getOwner());`
`@@ -217,7 +217,7 @@ int32_t CGameInfoCallback::getSpellCost(const spells::Spell * sp, const CGHeroIn`
`217`	`217`
`218`	`218`	`int64_t CGameInfoCallback::estimateSpellDamage(const CSpell * sp, const CGHeroInstance * hero) const`
`219`	`219`	`{`
`220`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`220`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`221`	`221`
`222`	`222`	`ERROR_RET_VAL_IF(hero && !canGetFullInfo(hero), "Cannot get info about caster!", -1);`
`223`	`223`
`@@ -229,7 +229,7 @@ int64_t CGameInfoCallback::estimateSpellDamage(const CSpell * sp, const CGHeroIn`
`229`	`229`
`230`	`230`	`void CGameInfoCallback::getThievesGuildInfo(SThievesGuildInfo & thi, const CGObjectInstance * obj)`
`231`	`231`	`{`
`232`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`232`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`233`	`233`	`ERROR_RET_IF(!obj, "No guild object!");`
`234`	`234`	`ERROR_RET_IF(obj->ID == Obj::TOWN && !canGetFullInfo(obj), "Cannot get info about town guild object!");`
`235`	`235`	`//TODO: advmap object -> check if they're visited by our hero`
`@@ -419,13 +419,13 @@ bool CGameInfoCallback::getHeroInfo(const CGObjectInstance * hero, InfoAboutHero`
`419`	`419`
`420`	`420`	`int CGameInfoCallback::getDate(Date mode) const`
`421`	`421`	`{`
`422`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`422`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`423`	`423`	`return gs->getDate(mode);`
`424`	`424`	`}`
`425`	`425`
`426`	`426`	`bool CGameInfoCallback::isVisible(int3 pos, const std::optional<PlayerColor> & Player) const`
`427`	`427`	`{`
`428`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`428`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`429`	`429`	`return gs->isVisible(pos, Player);`
`430`	`430`	`}`
`431`	`431`
`@@ -445,7 +445,7 @@ bool CGameInfoCallback::isVisible(const CGObjectInstance *obj) const`
`445`	`445`	`}`
`446`	`446`	`// const CCreatureSet* CInfoCallback::getGarrison(const CGObjectInstance *obj) const`
`447`	`447`	`// {`
`448`		`-// //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`448`	`+// //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`449`	`449`	`// if()`
`450`	`450`	`// const CArmedInstance armi = dynamic_cast<const CArmedInstance>(obj);`
`451`	`451`	`// if(!armi)`
`@@ -754,14 +754,14 @@ CGameInfoCallback::CGameInfoCallback(CGameState * GS):`
`754`	`754`
`755`	`755`	`int CPlayerSpecificInfoCallback::howManyTowns() const`
`756`	`756`	`{`
`757`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`757`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`758`	`758`	`ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);`
`759`	`759`	`return CGameInfoCallback::howManyTowns(*getPlayerID());`
`760`	`760`	`}`
`761`	`761`
`762`	`762`	`std::vector < const CGTownInstance *> CPlayerSpecificInfoCallback::getTownsInfo(bool onlyOur) const`
`763`	`763`	`{`
`764`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`764`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`765`	`765`	`auto ret = std::vector < const CGTownInstance *>();`
`766`	`766`	`for(const auto & i : gs->players)`
`767`	`767`	`{`
`@@ -777,7 +777,7 @@ std::vector < const CGTownInstance *> CPlayerSpecificInfoCallback::getTownsInfo(`
`777`	`777`	`}`
`778`	`778`	`std::vector < const CGHeroInstance *> CPlayerSpecificInfoCallback::getHeroesInfo(bool onlyOur) const`
`779`	`779`	`{`
`780`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`780`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`781`	`781`	`std::vector < const CGHeroInstance *> ret;`
`782`	`782`	`for(auto hero : gs->map->heroesOnMap)`
`783`	`783`	`{`
`@@ -840,7 +840,7 @@ std::vector <QuestInfo> CPlayerSpecificInfoCallback::getMyQuests() const`
`840`	`840`
`841`	`841`	`int CPlayerSpecificInfoCallback::howManyHeroes(bool includeGarrisoned) const`
`842`	`842`	`{`
`843`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`843`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`844`	`844`	`ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);`
`845`	`845`	`return getHeroCount(*getPlayerID(), includeGarrisoned);`
`846`	`846`	`}`
`@@ -872,14 +872,14 @@ const CGTownInstance* CPlayerSpecificInfoCallback::getTownBySerial(int serialId)`
`872`	`872`
`873`	`873`	`int CPlayerSpecificInfoCallback::getResourceAmount(GameResID type) const`
`874`	`874`	`{`
`875`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`875`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`876`	`876`	`ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);`
`877`	`877`	`return getResource(*getPlayerID(), type);`
`878`	`878`	`}`
`879`	`879`
`880`	`880`	`TResources CPlayerSpecificInfoCallback::getResourceAmount() const`
`881`	`881`	`{`
`882`		`- //std::shared_lock<boost::shared_mutex> lock(*gs->mx);`
	`882`	`+ //std::shared_lock<std::shared_mutex> lock(*gs->mx);`
`883`	`883`	`ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", TResources());`
`884`	`884`	`return gs->players[*getPlayerID()].resources;`
`885`	`885`	`}`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ namespace vstd`
`114`	`114`	`: unlock_guard<Mutex, detail::unlock_shared_policy<Mutex> >();`
`115`	`115`	`}`
`116`	`116`
`117`		`- using unlock_shared_guard = unlock_guard<boost::shared_mutex, detail::unlock_shared_policy<boost::shared_mutex>>;`
	`117`	`+ using unlock_shared_guard = unlock_guard<std::shared_mutex, detail::unlock_shared_policy<std::shared_mutex>>;`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`VCMI_LIB_NAMESPACE_END`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@`
`58`	`58`
`59`	`59`	`VCMI_LIB_NAMESPACE_BEGIN`
`60`	`60`
`61`		`-boost::shared_mutex CGameState::mutex;`
	`61`	`+std::shared_mutex CGameState::mutex;`
`62`	`62`
`63`	`63`	`HeroTypeID CGameState::pickNextHeroType(const PlayerColor & owner)`
`64`	`64`	`{`