BeltMgr Class Reference

#include "BeltMgr.h"

Collaboration diagram for BeltMgr:

Public Member Functions
	~BeltMgr ()

Protected Attributes
ManagerDB	m_db
Timer	m_respawnTimer

Private Attributes
SystemManager *	m_system
PyServiceMgr &	m_services
bool	m_initialized
uint32	m_systemID
uint32	m_regionID
std::map< uint32, bool >	m_spawned
std::map< uint32, bool >	m_active
std::map< uint32, InventoryItemRef >	m_belts
std::unordered_multimap < uint32, AsteroidSE * >	m_asteroids

BeltMgr.cpp
Asteroid Belt Spawn management system for EVEmu : Allan Date : 15 April 2016
	BeltMgr (SystemManager *mgr, PyServiceMgr &svc)
void	Init (uint32 regionID)
void	Save ()
void	Process ()
void	ClearAll ()
void	ClearBelt (uint16 bubbleID)
void	SetActive (uint16 bubbleID, bool active=true)
void	RegisterBelt (InventoryItemRef itemRef)
bool	Create (CosmicSignature &sig, std::unordered_multimap< float, uint16 > &roidTypes)
bool	Load (uint16 bubbleID)
bool	IsActive (uint16 bubbleID)
bool	IsSpawned (uint16 bubbleID)
void	CheckSpawn (uint16 bubbleID)
void	GetList (uint32 beltID, std::vector< AsteroidSE * > &list)
void	RemoveAsteroid (uint32 beltID, AsteroidSE *pASE)
void	SpawnBelt (uint16 bubbleID, std::unordered_multimap< float, uint16 > &roidTypes, int type=0, bool anomaly=false)
void	SpawnAsteroid (uint32 beltID, uint32 typeID, double radius, const GPoint &position, bool ice=false)
void	GetIceDist (uint8 quarter, float secStatus, std::unordered_multimap< float, uint16 > &roidDist)
uint32	GetAsteroidType (double p, const std::unordered_multimap< float, uint16 > &roids)

Detailed Description

Definition at line 34 of file BeltMgr.h.

Constructor & Destructor Documentation

BeltMgr::BeltMgr	(	SystemManager *	mgr,
		PyServiceMgr &	svc
	)

Note

roid save/load uses InventoryItem::Load(), which saves/reads from entity table, which we DONT want for roids. for now, save and load are disabled, roids are temp items, and use generic InventoryItem class. this will have to be revisited and corrected to properly implement persistent roids/belts

Definition at line 28 of file BeltMgr.cpp.

: m_respawnTimer(0),
m_system(mgr),
m_services(svc),
m_initialized(false)
{
}

BeltMgr::~BeltMgr ( )

inline

Definition at line 38 of file BeltMgr.h.

{ /* do nothing here */ }

Member Function Documentation

void BeltMgr::CheckSpawn

(

uint16

bubbleID

)

Definition at line 82 of file BeltMgr.cpp.

References IsSpawned(), Load(), and SpawnBelt().

Referenced by SystemBubble::Add().

{
    if (IsSpawned(bubbleID))
        return;
    /*  if there are already roids created for this belt, they will be loaded in Load()
     * if Load() has roids for this belt, this belt will have true already set, and checked in SpawnBelt()
     */
    if (!Load(bubbleID)) {
        std::unordered_multimap<float, uint16> roidTypes;
        roidTypes.clear();
        SpawnBelt(bubbleID, roidTypes);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BeltMgr::ClearAll

(

)

Definition at line 71 of file BeltMgr.cpp.

References m_asteroids, m_belts, m_system, SystemManager::RemoveEntity(), SafeDelete(), and Save().

Referenced by SystemManager::UnloadSystem().

                       {
    Save();
    for (auto cur : m_asteroids) {
        m_system->RemoveEntity(cur.second);
        //cur.second->Delete();
        SafeDelete(cur.second);
    }
    m_asteroids.clear();
    m_belts.clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BeltMgr::ClearBelt

(

uint16

bubbleID

)

Definition at line 66 of file BeltMgr.cpp.

{
    //ClearAll();
}

bool BeltMgr::Create	(	CosmicSignature &	sig,
		std::unordered_multimap< float, uint16 > &	roidTypes
	)

Definition at line 244 of file BeltMgr.cpp.

References SystemBubble::GetID(), SystemManager::GetSE(), SystemEntity::GetSelf(), m_system, SystemBubble::SetBelt(), CosmicSignature::sigItemID, SpawnBelt(), and SystemEntity::SysBubble().

Referenced by DungeonMgr::Create().

{
    // register this as a belt.
    SystemEntity* pSE = m_system->GetSE(sig.sigItemID);
    if (pSE == nullptr)
        return false;
    pSE->SysBubble()->SetBelt(pSE->GetSelf());
    SpawnBelt(pSE->SysBubble()->GetID(), roidTypes, 0, true);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 BeltMgr::GetAsteroidType ( double  p, const std::unordered_multimap< float, uint16 > &  roids  )

protected

Definition at line 362 of file BeltMgr.cpp.

References _log.

Referenced by SpawnBelt().

                                                                                           {
    std::unordered_multimap<float, uint16>::const_iterator cur = roids.begin();
    float chance = 0.0;
    for(; cur != roids.end(); ++cur ) {
        chance += cur->first;
        _log(COSMIC_MGR__DEBUG, "BeltMgr::GetAsteroidType - checking %u with chance %.3f(%.3f)", cur->second, chance, p);
        if (chance > p )
            return cur->second;
    }

    return 0;
}

Here is the caller graph for this function:

void BeltMgr::GetIceDist ( uint8  quarter, float  secStatus, std::unordered_multimap< float, uint16 > &  roidDist  )

protected

Definition at line 446 of file BeltMgr.cpp.

Referenced by SpawnBelt().

{
    // get map region for ice distro
    switch (quarter) {
        case 1: {       // caldari
            if (secStatus < 0.0) {
                roidDist.insert(std::pair<float,uint32>(0.2, 16265));    // White Glaze - caldari
                roidDist.insert(std::pair<float,uint32>(0.16, 16266));   // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.16, 16267));   // Dark Glitter - all but gallente < 0.1
                roidDist.insert(std::pair<float,uint32>(0.16, 17976));   // Pristine White Glaze - caldari < 0.0
                roidDist.insert(std::pair<float,uint32>(0.16, 16268));   // Gelidus - all < 0.0
                roidDist.insert(std::pair<float,uint32>(0.16, 16269));   // Krystallos - all < 0.0
            } else if (secStatus < 0.1) {
                roidDist.insert(std::pair<float,uint32>(0.70, 16265));   // White Glaze - caldari
                roidDist.insert(std::pair<float,uint32>(0.20, 16266));   // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.10, 16267));   // Dark Glitter - all but gallente < 0.1
            } else if (secStatus < 0.4) {
                roidDist.insert(std::pair<float,uint32>(0.75, 16265));   // White Glaze - caldari
                roidDist.insert(std::pair<float,uint32>(0.25, 16266));   // Glare Crust - all < 0.4
            } else {
                roidDist.insert(std::pair<float,uint32>(1.0, 16265));    // White Glaze - caldari
            }
        } break;
        case 2: {       // minmatar
            if (secStatus < 0.0) {
                roidDist.insert(std::pair<float,uint32>(0.2, 16263));    // Glacial Mass - minmatar
                roidDist.insert(std::pair<float,uint32>(0.16, 16266));   // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.16, 16267));   // Dark Glitter - all but gallente < 0.1
                roidDist.insert(std::pair<float,uint32>(0.16, 17977));   // Smooth Glacial Mass - minmatar < 0.0
                roidDist.insert(std::pair<float,uint32>(0.16, 16268));   // Gelidus - all < 0.0
                roidDist.insert(std::pair<float,uint32>(0.16, 16269));   // Krystallos - all < 0.0
            } else if (secStatus < 0.1) {
                roidDist.insert(std::pair<float,uint32>(0.70, 16263));   // Glacial Mass - minmatar
                roidDist.insert(std::pair<float,uint32>(0.20, 16266));   // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.10, 16267));   // Dark Glitter - all but gallente < 0.1
            } else if (secStatus < 0.4) {
                roidDist.insert(std::pair<float,uint32>(0.75, 16263));   // Glacial Mass - minmatar
                roidDist.insert(std::pair<float,uint32>(0.25, 16266));   // Glare Crust - all < 0.4
            } else {
                roidDist.insert(std::pair<float,uint32>(1.0, 16263));    // Glacial Mass - minmatar
            }
        } break;
        case 3: {       //amarr
            if (secStatus < 0.0) {
                roidDist.insert(std::pair<float,uint32>(0.2, 16262));    // Clear Icicle - amarr
                roidDist.insert(std::pair<float,uint32>(0.16, 16266));   // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.16, 16267));   // Dark Glitter - all but gallente < 0.1
                roidDist.insert(std::pair<float,uint32>(0.16, 17978));   // Enriched Clear Icicle - amarr < 0.0
                roidDist.insert(std::pair<float,uint32>(0.16, 16268));   // Gelidus - all < 0.0
                roidDist.insert(std::pair<float,uint32>(0.16, 16269));   // Krystallos - all < 0.0
            } else if (secStatus < 0.1) {
                roidDist.insert(std::pair<float,uint32>(0.70, 16262));   // Clear Icicle - amarr
                roidDist.insert(std::pair<float,uint32>(0.20, 16266));   // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.10, 16267));   // Dark Glitter - all but gallente < 0.1
            } else if (secStatus < 0.4) {
                roidDist.insert(std::pair<float,uint32>(0.75, 16262));   // Clear Icicle - amarr
                roidDist.insert(std::pair<float,uint32>(0.25, 16266));   // Glare Crust - all < 0.4
            } else {
                roidDist.insert(std::pair<float,uint32>(1.0, 16262));    // Clear Icicle - amarr
            }
        } break;
        case 4: {       //gallente
            if (secStatus < 0.0) {
                roidDist.insert(std::pair<float,uint32>(0.3, 16264));    // Blue Ice - gallente
                roidDist.insert(std::pair<float,uint32>(0.17, 16266));   // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.17, 17975));   // Thick Blue Ice - gallente < 0.0
                roidDist.insert(std::pair<float,uint32>(0.17, 16268));   // Gelidus - all < 0.0
                roidDist.insert(std::pair<float,uint32>(0.17, 16269));   // Krystallos - all < 0.0
            } else if (secStatus < 0.4) {
                roidDist.insert(std::pair<float,uint32>(0.75, 16264));   // Blue Ice - gallente
                roidDist.insert(std::pair<float,uint32>(0.25, 16266));   // Glare Crust - all < 0.4
            } else {
                roidDist.insert(std::pair<float,uint32>(1.0, 16264));    // Blue Ice - gallente
            }
        } break;
        case 5: {       // none?  no region quarter?
            if (secStatus < 0.0) {
                roidDist.insert(std::pair<float,uint32>(0.4, 16266));    // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.2, 16267));    // Dark Glitter - all but gallente < 0.1
                roidDist.insert(std::pair<float,uint32>(0.2, 16268));    // Gelidus - all < 0.0
                roidDist.insert(std::pair<float,uint32>(0.2, 16269));    // Krystallos - all < 0.0
            } else if (secStatus < 0.1) {
                roidDist.insert(std::pair<float,uint32>(0.75, 16266));   // Glare Crust - all < 0.4
                roidDist.insert(std::pair<float,uint32>(0.25, 16267));   // Dark Glitter - all but gallente < 0.1
            } else if (secStatus < 0.4) {
                roidDist.insert(std::pair<float,uint32>(1.0, 16266));    // Glare Crust - all < 0.4
            }
        } break;
    }
}

Here is the caller graph for this function:

void BeltMgr::GetList	(	uint32	beltID,
		std::vector< AsteroidSE * > &	list
	)

Definition at line 221 of file BeltMgr.cpp.

References m_asteroids.

Referenced by Command_beltlist(), and ActiveModule::DeactivateCycle().

{
    auto range = m_asteroids.equal_range(beltID);
    for (auto itr = range.first; itr != range.second; ++itr)
        list.push_back(itr->second);
}

Here is the caller graph for this function:

void BeltMgr::Init

(

uint32

regionID

)

Definition at line 36 of file BeltMgr.cpp.

References _log, SystemManager::GetID(), SystemManager::GetName(), m_active, m_belts, m_initialized, m_regionID, m_respawnTimer, m_spawned, m_system, m_systemID, sConfig, and Timer::Start().

Referenced by SystemManager::LoadCosmicMgrs().

{
    if (!sConfig.cosmic.BeltEnabled) {
        _log(COSMIC_MGR__MESSAGE, "BeltMgr System Disabled.  Not Initializing Belt Manager for %s(%u)", m_system->GetName(), m_system->GetID());
        return;
    }

    m_belts.clear();
    m_active.clear();
    m_spawned.clear();

    assert(m_system != nullptr);

    m_regionID = regionID;
    m_systemID = m_system->GetID();
    m_respawnTimer.Start(sConfig.cosmic.BeltRespawn *60 *60 *1000);  // hours->ms

    m_initialized = true;
    _log(COSMIC_MGR__MESSAGE, "BeltMgr Initialized for %s(%u)", m_system->GetName(), m_systemID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool BeltMgr::IsActive

(

uint16

bubbleID

)

Definition at line 105 of file BeltMgr.cpp.

References m_active, and sBubbleMgr.

Referenced by AsteroidSE::Process().

{
    uint32 beltID = sBubbleMgr.GetBeltID(bubbleID);
    std::map<uint32, bool>::iterator itr = m_active.find(beltID);
    if (itr != m_active.end())
        return itr->second;
    return false;
}

Here is the caller graph for this function:

bool BeltMgr::IsSpawned

(

uint16

bubbleID

)

Definition at line 96 of file BeltMgr.cpp.

References m_spawned, and sBubbleMgr.

Referenced by CheckSpawn(), and SpawnBelt().

{
    uint32 beltID = sBubbleMgr.GetBeltID(bubbleID);
    std::map<uint32, bool>::iterator itr = m_spawned.find(beltID);
    if (itr != m_spawned.end())
        return itr->second;
    return false;
}

Here is the caller graph for this function:

bool BeltMgr::Load

(

uint16

bubbleID

)

Definition at line 139 of file BeltMgr.cpp.

References _log, SystemManager::AddEntity(), AttrMass, AttrQuantity, AttrRadius, AttrVolume, RefPtr< X >::get(), SystemManager::GetName(), SystemManager::GetServiceMgr(), ManagerDB::LoadSystemRoids(), m_active, m_asteroids, m_db, m_spawned, m_system, m_systemID, sBubbleMgr, AsteroidSE::SetMgr(), and sItemFactory.

Referenced by CheckSpawn().

                                  {
    std::vector<AsteroidData> entities;
    entities.clear();
    uint32 beltID = sBubbleMgr.GetBeltID(bubbleID);
    if (beltID == 0)
        return false;
    if (!m_db.LoadSystemRoids(m_systemID, beltID, entities))
        return false;

    for (auto entity : entities) {
        AsteroidItemRef itemRef = sItemFactory.GetAsteroid(entity.itemID);
        if (itemRef.get() == nullptr) {
            _log(COSMIC_MGR__WARNING, "BeltMgr::Load() -  Unable to spawn item #%u:'%s' of type %u.", entity.itemID, entity.itemName.c_str(), entity.typeID);
            continue;
        }
        // set attribs using loaded values from asteroid table.
        itemRef->SetAttribute(AttrRadius,    itemRef->type().radius() * entity.radius); // Radius
        itemRef->SetAttribute(AttrQuantity,  entity.quantity);                          // Quantity
        itemRef->SetAttribute(AttrVolume,    itemRef->type().volume());                 // Volume
        itemRef->SetAttribute(AttrMass,      itemRef->type().mass() * entity.quantity); // Mass

        AsteroidSE* pASE = new AsteroidSE(itemRef, *(m_system->GetServiceMgr()), m_system );
        if (pASE == nullptr) {
            _log(COSMIC_MGR__WARNING, "BeltMgr::Load() -  Unable to spawn itemID %u - %s (type %u).", entity.itemID, entity.itemName.c_str(), entity.typeID);
            continue;
        }
        _log(COSMIC_MGR__TRACE, "BeltMgr::Load() - Loaded asteroid %u, type %u for %s(%u)", entity.itemID, entity.typeID, m_system->GetName(), m_systemID );
        m_system->AddEntity(pASE);
        m_asteroids.emplace(std::pair<uint32, AsteroidSE*>(beltID, pASE));
        pASE->SetMgr(this, beltID);
    }
    std::map<uint32, bool>::iterator itr = m_spawned.find(beltID);
    if (itr == m_spawned.end()) {
        m_spawned.insert(std::pair<uint32, bool>(beltID, true));
    } else {
        itr->second = true;
    }

    itr = m_active.find(beltID);
    if (itr == m_active.end()) {
        m_active.insert(std::pair<uint32, bool>(beltID, true));
    } else {
        itr->second = true;
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BeltMgr::Process

(

)

Definition at line 125 of file BeltMgr.cpp.

References Timer::Check(), m_initialized, m_respawnTimer, m_spawned, and SpawnBelt().

Referenced by SystemManager::ProcessTic().

                      {
    if (!m_initialized)
        return;

    if (m_respawnTimer.Check()) {
        for (auto cur : m_spawned)
            if (!cur.second) {
                std::unordered_multimap<float, uint16> roidTypes;
                roidTypes.clear();
                SpawnBelt(cur.first, roidTypes);
            }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BeltMgr::RegisterBelt

(

InventoryItemRef

itemRef

)

Definition at line 57 of file BeltMgr.cpp.

References m_active, m_belts, and m_spawned.

Referenced by SystemBubble::SetBelt().

{
    uint32 beltID = itemRef->itemID();
    m_belts.insert(std::pair<uint32, InventoryItemRef>(beltID, itemRef));
    m_active.insert(std::pair<uint32, bool>(beltID, false));
    m_spawned.insert(std::pair<uint32, bool>(beltID, false));
}

Here is the caller graph for this function:

void BeltMgr::RemoveAsteroid	(	uint32	beltID,
		AsteroidSE *	pASE
	)

Definition at line 424 of file BeltMgr.cpp.

References SystemEntity::GetID(), m_asteroids, m_db, and ManagerDB::RemoveAsteroid().

Referenced by AsteroidSE::Delete().

{
    m_db.RemoveAsteroid(pASE->GetID());
    // this doesnt work right.  not sure why yet.
    auto range = m_asteroids.equal_range(beltID);
    for (auto itr = range.first; itr != range.second; ++itr) {
        if (itr->second == pASE) {
            m_asteroids.erase(itr);
            return;
        }
    }
/*
    if (m_asteroids.count(beltID)) {
        std::map<uint32, bool>::iterator itr =  m_spawned.find(beltID);
        if (itr != m_spawned.end())
            itr->second = false;
        else
            m_spawned.insert(std::pair<uint32, bool>(beltID, false));
    }
*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BeltMgr::Save

(

)

Definition at line 187 of file BeltMgr.cpp.

References _log, AsteroidData::beltID, SystemManager::GetName(), GetTimeUSeconds(), IsTempItem, AsteroidData::itemID, AsteroidData::itemName, m_asteroids, m_db, m_system, m_systemID, AsteroidData::position, AsteroidData::quantity, AsteroidData::radius, ManagerDB::SaveSystemRoids(), AsteroidData::systemID, and AsteroidData::typeID.

Referenced by ClearAll().

                   {
    if (m_asteroids.empty()) {
        _log(COSMIC_MGR__TRACE, "BeltMgr::Save - m_asteroids is empty for %s(%u).  nothing to save.", m_system->GetName(), m_systemID);
        return;
    }

    double start = GetTimeUSeconds();
    std::vector<AsteroidData> roids;
    roids.clear();
    uint16 save(0), skip(0);
    for (auto cur : m_asteroids) {
        // we are not saving anomaly belts (yet.  small belts in anomalies will become their own grav sites (wip))
        if (IsTempItem(cur.first)) {
            ++skip;
            continue;
        }
        AsteroidData entry = AsteroidData();
        entry.itemID = cur.second->GetID();
        entry.itemName = cur.second->GetName();
        entry.typeID = cur.second->GetSelf()->typeID();
        entry.systemID = m_systemID;
        entry.beltID = cur.first;
        entry.radius = cur.second->GetRadius();
        entry.quantity = ((25000 * log(entry.radius)) - 112404.8);   // quantity in m^3
        entry.position = cur.second->GetPosition();
        roids.push_back(entry);
        ++save;
    }

    m_db.SaveSystemRoids(m_systemID, roids);
    _log(COSMIC_MGR__TRACE, "BeltMgr::Save - Saving %u Asteroids for %s(%u) took %.3fus.  Skipped %u temp anomaly asteroids.", \
            save, m_system->GetName(), m_systemID, (GetTimeUSeconds() - start), skip);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BeltMgr::SetActive	(	uint16	bubbleID,
		bool	active = true
	)

Definition at line 114 of file BeltMgr.cpp.

References m_active, and sBubbleMgr.

Referenced by MiningLaser::CanActivate().

{
    uint32 beltID = sBubbleMgr.GetBeltID(bubbleID);
    std::map<uint32, bool>::iterator itr = m_active.find(beltID);
    if (itr != m_active.end()) {
        itr->second = active;
    } else {
        m_active.insert(std::pair<uint32, bool>(beltID, active));
    }
}

Here is the caller graph for this function:

void BeltMgr::SpawnAsteroid ( uint32  beltID, uint32  typeID, double  radius, const GPoint &  position, bool  ice = false  )

protected

Definition at line 375 of file BeltMgr.cpp.

References _log, SystemManager::AddEntity(), AsteroidData::beltID, flagNone, RefPtr< X >::get(), SystemManager::GetServiceMgr(), IsNaN(), IsTempItem, m_asteroids, m_system, m_systemID, ownerSystem, AsteroidData::position, AsteroidData::quantity, AsteroidData::radius, sConfig, AsteroidSE::SetMgr(), sItemFactory, AsteroidItem::SpawnTemp(), AsteroidData::systemID, and AsteroidData::typeID.

Referenced by SpawnBelt().

                                                                                                          {
    if (typeID == 0) {
        _log(COSMIC_MGR__WARNING, "BeltMgr::SpawnAsteroid - typeID is 0");
        return;
    }
    if (IsNaN(radius)) {
        _log(COSMIC_MGR__WARNING, "BeltMgr::SpawnAsteroid - radius is NaN");
        return;
    }
    if (radius <= 0) {
        _log(COSMIC_MGR__WARNING, "BeltMgr::SpawnAsteroid - radius < 0");
        return;
    }

    double quantity = 0;
    if (ice) {
        quantity = radius * 2;
    } else {
        radius *= sConfig.cosmic.roidRadiusMultiplier;
        //Amount of Ore = (25000*ln(Radius))-112404.8   V = 25000Ln(r) - 112407
        quantity = ((25000 * log(radius)) - 112404.8);
    }

    AsteroidData adata = AsteroidData();
        adata.beltID = beltID;
        adata.systemID = m_systemID;
        adata.typeID = typeID;
        adata.quantity = quantity;
        adata.radius = radius;
        adata.position = position;
    ItemData idata(typeID, ownerSystem, m_systemID, flagNone, "", position);
    InventoryItemRef iRef(nullptr);
    if (IsTempItem(beltID)) {
        iRef = AsteroidItem::SpawnTemp(idata, adata);   // create temp item for anomaly belt
    } else {
        iRef = sItemFactory.SpawnAsteroid(idata, adata);
    }
    if (iRef.get() == nullptr)
        return;

    AsteroidSE* pASE = new AsteroidSE( iRef, *(m_system->GetServiceMgr()), m_system );
    if (pASE == nullptr)
        return;

    m_asteroids.emplace(std::pair<uint32, AsteroidSE*>(beltID, pASE));
    pASE->SetMgr(this, beltID);
    m_system->AddEntity(pASE, false);   // we're not adding roids to signal list
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BeltMgr::SpawnBelt ( uint16  bubbleID, std::unordered_multimap< float, uint16 > &  roidTypes, int  type = 0, bool  anomaly = false  )

protected

Definition at line 255 of file BeltMgr.cpp.

References _log, EvE::Trig::Deg2Rad(), GetAsteroidType(), SystemBubble::GetCenter(), GetIceDist(), SystemManager::GetName(), SystemManager::GetSE(), SystemManager::GetSecValue(), SystemManager::GetSystemSecurityClass(), SystemManager::GetSystemSecurityRating(), SystemEntity::GetTypeID(), IsCelestialID, IsSpawned(), m_active, m_regionID, m_spawned, m_system, m_systemID, MakeRandomFloat(), MakeRandomInt(), NULL_ORIGIN(), EvE::Trig::Pi, sBubbleMgr, sConfig, sDataMgr, SpawnAsteroid(), and SystemEntity::SysBubble().

Referenced by CheckSpawn(), Create(), and Process().

{
    if (IsSpawned(bubbleID))
        return;

    uint32 beltID = sBubbleMgr.GetBeltID(bubbleID);
    if ((!IsCelestialID(beltID)) and (!anomaly))
        return;

    SystemEntity* pSE = m_system->GetSE(beltID);
    if (pSE == nullptr)
        return;

    bool ice = (pSE->GetTypeID() == 17774);

    float secRating = m_system->GetSystemSecurityRating();
    float secValue = m_system->GetSecValue();
    std::unordered_multimap<float, uint16> roidDist;
    if (ice) {
        // caldari=1, minmatar=2, amarr=3, gallente=4, none=5
        GetIceDist(sDataMgr.GetRegionQuarter(m_regionID), secRating, roidDist);
    } else if (anomaly) {
        roidDist = roidTypes;
    } else {
        sDataMgr.GetRoidDist(m_system->GetSystemSecurityClass(), roidDist);
    }

    int8 pcs = 5;
    double radius = 8000;
    radius *= sConfig.cosmic.roidRadiusMultiplier;
    double roidradius = 0, theta = 0, randRadius = 0, elevation = 0;
    if (anomaly) {
        pcs += roidDist.size();
        radius += (radius * secValue);
        radius += (pcs * 1000 / 4);
        elevation = (radius / 4);
    } else if (ice) {  //880 total systems with ice. 293 in hisec
        //  ice needs to be 30k to 75k, with radius of 40k to 100k
        radius *= 3; //24k base
        if (secRating > 0.7) {
            pcs = 1;
        } else if (secRating > 0.4) {
            pcs = 2;
        } else if (secRating > 0.0) {
            pcs = 3;
        } else if (secRating > -0.4) {
            pcs = 4;
        } else {
            pcs = 6;
        }
    } else {
        pcs += MakeRandomInt(5, 30);
        radius += (radius * secValue);
        radius += (pcs * 1000 / 4);
        elevation = (radius / 4);
    }

    double degreeSeparation = (180 / pcs);
    ++pcs;
    GPoint center(pSE->SysBubble()->GetCenter());
    GPoint mposition(NULL_ORIGIN);
    for (uint8 i = 1; i < pcs; ++i) {
        if (ice) {
            if (secRating > -0.2) {
                roidradius = MakeRandomInt(20, 40) * 1000; // (40k,70k)  72-102k radius
            } else {
                roidradius = MakeRandomInt(40, 70) * 1000; // (40k,80k)  82-112k radius
            }
            radius += roidradius;
            elevation = (radius + (roidradius / 2) / 2);
        } else {
            roidradius = MakeRandomInt(3000, 8000) * secValue;
        }
        if (anomaly) {
            // random for anomaly...use the "special" placements at end of this file....eventually.
            theta = MakeRandomFloat(0, (EvE::Trig::Pi*2));
            mposition.x = (radius + roidradius / 5) * cos(theta);
            mposition.z = (radius + roidradius / 5) * sin(theta);
        } else if (type == 0) {
            randRadius = MakeRandomFloat(-radius / 4, radius / 2);
            // half-circle type
            theta = EvE::Trig::Deg2Rad(degreeSeparation * i);
            mposition.x = (randRadius + roidradius + radius) * cos(theta);
            mposition.z = (randRadius + roidradius + radius) * sin(theta);
        }
        mposition.y = MakeRandomFloat(-elevation, elevation);
        SpawnAsteroid(beltID, GetAsteroidType(MakeRandomFloat(), roidDist), roidradius, (center + mposition), ice);
    }

    std::map<uint32, bool>::iterator itr = m_spawned.find(beltID);
    if (itr == m_spawned.end()) {
        m_spawned.insert(std::pair<uint32, bool>(beltID, true));
    } else {
        itr->second = true;
    }

    itr = m_active.find(beltID);
    if (itr == m_active.end()) {
        m_active.insert(std::pair<uint32, bool>(beltID, false));
    } else {
        itr->second = false;
    }

    _log(COSMIC_MGR__TRACE, "BeltMgr::SpawnBelt - Belt spawned with %u roids of %s in %s %u for %s(%u)", \
            pcs, (ice?"ice":"ore"), (anomaly?"anomalyID":"beltID"), beltID, m_system->GetName(), m_systemID );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::map<uint32, bool> BeltMgr::m_active

private

Definition at line 79 of file BeltMgr.h.

Referenced by Init(), IsActive(), Load(), RegisterBelt(), SetActive(), and SpawnBelt().

std::unordered_multimap<uint32, AsteroidSE*> BeltMgr::m_asteroids

private

Definition at line 83 of file BeltMgr.h.

Referenced by ClearAll(), GetList(), Load(), RemoveAsteroid(), Save(), and SpawnAsteroid().

std::map<uint32, InventoryItemRef> BeltMgr::m_belts

private

Definition at line 81 of file BeltMgr.h.

Referenced by ClearAll(), Init(), and RegisterBelt().

ManagerDB BeltMgr::m_db

protected

Definition at line 59 of file BeltMgr.h.

Referenced by Load(), RemoveAsteroid(), and Save().

bool BeltMgr::m_initialized

private

Definition at line 72 of file BeltMgr.h.

Referenced by Init(), and Process().

uint32 BeltMgr::m_regionID

private

Definition at line 74 of file BeltMgr.h.

Referenced by Init(), and SpawnBelt().

Timer BeltMgr::m_respawnTimer

protected

Definition at line 60 of file BeltMgr.h.

Referenced by Init(), and Process().

PyServiceMgr& BeltMgr::m_services

private

Definition at line 70 of file BeltMgr.h.

std::map<uint32, bool> BeltMgr::m_spawned

private

Definition at line 77 of file BeltMgr.h.

Referenced by Init(), IsSpawned(), Load(), Process(), RegisterBelt(), and SpawnBelt().

SystemManager* BeltMgr::m_system

private

Definition at line 69 of file BeltMgr.h.

Referenced by ClearAll(), Create(), Init(), Load(), Save(), SpawnAsteroid(), and SpawnBelt().

uint32 BeltMgr::m_systemID

private

Definition at line 73 of file BeltMgr.h.

Referenced by Init(), Load(), Save(), SpawnAsteroid(), and SpawnBelt().

---

The documentation for this class was generated from the following files:

• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/system/cosmicMgrs/BeltMgr.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/system/cosmicMgrs/BeltMgr.cpp