Scan Class Reference

#include "Scan.h"

Collaboration diagram for Scan:

Public Member Functions
	~Scan ()
uint8	GetProbeCount ()

Private Attributes
ManagerDB *	m_db
Client *	m_client
SystemManager *	m_system
bool	m_probeScan
std::map< uint32, ProbeSE * >	m_probeMap
std::map< uint32, ProbeSE * >	m_activeProbeMap

Scan.cpp
Scanning methods for EVEmu : Allan Date : 7Dec15 (working) : 12Mar18 (probes) Version : 0.42
	Scan (Client *pClient)
void	ProcessScan (bool useProbe=false)
PyRep *	ConeScan (Call_ConeScan args)
void	RequestScans (PyDict *dict)
void	ShipScanResult ()
void	ProbeScanResult ()
void	SystemScanStarted (uint16 duration)
void	AddProbe (ProbeSE *pProbe)
void	RemoveProbe (ProbeSE *pProbe)
bool	GetProbeDataForSig (SignalData &data)
void	GetSignalData (SignalData &data, std::vector< ProbeSE * > &probeVec)
void	ScanStart ()
void	SurveyScan ()
void	CalcProbeAngles (GPoint &sigPos, std::vector< ProbeSE * > &probeVec, std::map< float, std::pair< ProbeSE *, ProbeSE * >> &angleMap)

Detailed Description

Definition at line 32 of file Scan.h.

Constructor & Destructor Documentation

Scan::Scan

(

Client *

pClient

)

Definition at line 36 of file Scan.cpp.

References m_activeProbeMap, m_probeMap, and m_probeScan.

: m_client(pClient),
  m_system(pClient->SystemMgr())
{
    m_probeScan = false;
    m_probeMap.clear();
    m_activeProbeMap.clear();
}

Scan::~Scan ( )

inline

Definition at line 36 of file Scan.h.

{ /* do nothing here */ }

Member Function Documentation

void Scan::AddProbe

(

ProbeSE *

pProbe

)

Definition at line 45 of file Scan.cpp.

References SystemEntity::GetID(), m_probeMap, and ProbeSE::SetScan().

Referenced by ActiveModule::LaunchProbe().

{
    pProbe->SetScan(this);
    m_probeMap.emplace(pProbe->GetID(), pProbe);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Scan::CalcProbeAngles ( GPoint &  sigPos, std::vector< ProbeSE * > &  probeVec, std::map< float, std::pair< ProbeSE *, ProbeSE * >> &  angleMap  )

private

Definition at line 681 of file Scan.cpp.

References _log, SystemEntity::GetID(), SystemEntity::GetPosition(), Ga::GaVec3::normalize(), and y().

Referenced by GetSignalData().

                                                                                                                               {
    bool run(true);
    uint8 count(probeVec.size()), x(0), y(1);
    float dot(0.0f), angle(0.0f);
    ProbeSE* p1(nullptr);
    while (x < count) {
        p1 = probeVec.at(x++);
        if (p1 == nullptr)
            continue;
        GVector v1(p1->GetPosition(), sigPos);
        v1.normalize();
        for (auto cur : probeVec) {
            if ((cur == nullptr) or (p1 == cur))
                continue;
            GVector v2(cur->GetPosition(), sigPos);
            v2.normalize();
            dot = v1.dotProduct(v2);        // cosine of angle between v1,v2
            angle = acos(dot);              // angle in rad
            // if this probe set is already inserted, skip and move along.
            if (angleMap.find(angle) != angleMap.end())
                continue;
            // add to map
            angleMap[angle] = std::make_pair(p1, cur);
            _log(SCAN__DEBUG, "Scan::CalcProbeAngles() - adding angle %.3f, p1 %u, p2 %u to map",\
                    /*EvE::Trig::Rad2Deg*/(angle), p1->GetID(), cur->GetID());
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyRep * Scan::ConeScan

(

Call_ConeScan

args

)

Definition at line 99 of file Scan.cpp.

References _log, SystemManager::DScan(), SystemEntity::GetPosition(), Client::GetShipSE(), m_client, Ga::GaVec3::normalize(), and Client::SystemMgr().

                                        {
    //  WORKING CODE...DONT FUCK WITH THIS!!  -allan 7Dec15

    // NOTE:  max distance is 14.4AU or maxInt (2417482647 in km)
    /* to find if a point is inside a cone.     (-allan 10Aug20)
     * U = unit vector along cone axis (sent from client, decoded as x,y,z)
     * VR = vector from cone vertex(V) to test point(R).
     * Uvr = unit vector of cone vertex to test point (normalized VR)
     * DP = Uvr dot U (dot product of Uvr and U).  this will give cosine of angle between VR and U
     * acDP = arc cosine of DP to give angle
     * test acDP < cone angle = point is inside cone.
     */
    bool test = false;
    float dot(0), acDP(0), angle(args.ScanAngle/2);
    std::vector<SystemEntity*> seVec;
    const GPoint vertex(m_client->GetShipSE()->GetPosition());
    const GPoint U(args.x, args.y, args.z);
    m_client->SystemMgr()->DScan(args.range, vertex, seVec);
    _log(SCAN__TRACE, "ConeScan() - query returned %u objects within range.  angle is %.3f", seVec.size(), angle);
    PyList* list = new PyList();
    for (auto cur : seVec ) {
        GVector VR(vertex, cur->GetPosition());
        VR.normalize();
        dot = U.dotProduct(VR);
        acDP = acos(dot);
        if (acDP < angle) {
            test = true;
            DirectionScanResult res;
            res.id         = cur->GetID();
            res.typeID     = cur->GetSelf()->typeID();
            res.groupID    = cur->GetSelf()->groupID();
            list->AddItem(res.Encode());
        }
        _log(SCAN__TRACE, "ConeScan() - tested %s(%u).  dot %.5f, acDP %.5f, result %s", cur->GetName(), cur->GetID(), dot, acDP, test?"true":"false");
        test = false;
    }

    return list;
}

Here is the call graph for this function:

uint8 Scan::GetProbeCount ( )

inline

Definition at line 41 of file Scan.h.

References m_probeMap.

Referenced by ActiveModule::LaunchProbe().

{ return (uint8)m_probeMap.size(); }

Here is the caller graph for this function:

bool Scan::GetProbeDataForSig

(

SignalData &

data

)

Definition at line 425 of file Scan.cpp.

References _log, PyList::AddItem(), Scanning::Group::DroneOrProbe, CosmicSignature::dungeonType, Dungeon::Type::Escalation, SystemManager::GetAnomMgr(), AnomalyMgr::GetScanGroupName(), GetSignalData(), m_activeProbeMap, m_system, Dungeon::Type::Mission, NULL_ORIGIN(), ONE_AU_IN_METERS, CosmicSignature::position, SignalData::probePos, SignalData::probes, Dungeon::Type::Rated, CosmicSignature::scanGroupID, PyTuple::SetItem(), Scanning::Group::Ship, SignalData::sig, CosmicSignature::sigName, Scanning::Group::Signature, Scanning::Group::Structure, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by ProbeScanResult().

{
    /*  this will determine sig position vs probe position, range, strength
     * to decide if this sig is picked up by a probe, and return probe data
     * based on that.
     *
struct CosmicSignature {
    uint8 dungeonType;
    uint16 sigTypeID;
    uint16 sigGroupID;
    uint16 scanGroupID;
    uint16 scanAttributeID;
    uint32 ownerID;
    uint32 systemID;
    uint32 sigItemID;   // itemID of this entry
    GPoint position;
    std::string sigID;  // this is unique xxx-nnn id displayed in scanner
    std::string sigName;
};
     */

    bool hit(false);
    float dist(0);
    std::vector<ProbeSE*> probeVec;
    // check probe scan ranges for signals; verify probe can scan signal
    for (auto cur : m_activeProbeMap) {
        // reset ring/sphere checks
        cur.second->SetRing(false);
        cur.second->SetSphere(false);
        switch (data.sig.scanGroupID) {
            case Scanning::Group::Ship:
            case Scanning::Group::DroneOrProbe:
            case Scanning::Group::Structure: {
                if (cur.second->CanScanShips()) {
                    dist = cur.second->GetPosition().distance(data.sig.position);
                    if (cur.second->GetScanRange() > dist) {
                        hit = true;
                        probeVec.push_back(cur.second);
                    }
                    _log(SCAN__DEBUG, "Scan::GetProbeDataForSig()  scan range for probe %u: %.2fAU, distance to signal '%s' -> %.2fAU - %s",\
                            cur.first, cur.second->GetScanRange() /ONE_AU_IN_METERS, data.sig.sigName.c_str(), \
                            dist /ONE_AU_IN_METERS, hit?"hit":"miss");
                } else {
                    _log(SCAN__TRACE, "Scan::GetProbeDataForSig()  probe %u cannot scan signal %s", cur.first, data.sig.sigName.c_str());
                }
            } break;
            case Scanning::Group::Signature: {
                switch (data.sig.dungeonType) {
                    case Dungeon::Type::Mission: // npc mission
                    case Dungeon::Type::Escalation://  new dungeon from previous site. very limited access
                    case Dungeon::Type::Rated: { // DED rated dungeon
                        _log(SCAN__TRACE, "Scan::GetProbeDataForSig()  probe %u cannot scan signal %s", cur.first, data.sig.sigName.c_str());
                        continue;
                    }
                /*  nothing to check for on these...
                    case Dungeon::Type::Gravimetric:// roids
                    case Dungeon::Type::Magnetometric:// salvage and archeology
                    case Dungeon::Type::Radar:// hacking
                    case Dungeon::Type::Ladar: // gas mining
                    case Dungeon::Type::Wormhole:
                    case Dungeon::Type::Anomaly:// non-rated dungeon that isnt required to scan with probes - will not hit here.
                    case Dungeon::Type::Unrated:// non-rated dungeon  no waves, possible escalation to complex
                        break;
                */
                }
            } // this probe can scan this signal; fall thru to add probe to signal's map
            default: {
                dist = cur.second->GetPosition().distance(data.sig.position);
                if (cur.second->GetScanRange() > dist) {
                    hit = true;
                    probeVec.push_back(cur.second);
                }
                _log(SCAN__DEBUG, "Scan::GetProbeDataForSig()  scan range for probe %u: %.2fAU, distance to signal '%s' -> %.2fAU - %s",\
                        cur.first, cur.second->GetScanRange() /ONE_AU_IN_METERS, data.sig.sigName.c_str(), \
                        dist /ONE_AU_IN_METERS, hit?"hit":"miss");
            } break;
        }
        hit = false;
    }

    _log(SCAN__TRACE, "Scan::GetProbeDataForSig()  probeVec size: %u for signal %s (%s)", \
            probeVec.size(), data.sig.sigName.c_str(), m_system->GetAnomMgr()->GetScanGroupName(data.sig.scanGroupID));

    if (probeVec.empty())
        return false;

    // at this point, we have at least one probe scanning at least one signal
    GetSignalData(data, probeVec);
    if (probeVec.size() > 1) {
        bool isRing(false);
        uint8 count(0);
        GPoint pos(NULL_ORIGIN);
        PyList* list = new PyList();
        PyList* ring = new PyList();
        PyTuple* tuple = new PyTuple(probeVec.size());
        for (auto cur : probeVec) {
            tuple->SetItem(count++, new PyInt(cur->GetID()));
            pos = cur->GetPosition();
            ScanResultPos ssr_oed;
                ssr_oed.x = pos.x;
                ssr_oed.y = pos.y;
                ssr_oed.z = pos.z;
            PyToken* token = new PyToken("foo.Vector3");
            PyTuple* oed_tuple = new PyTuple(2);
                oed_tuple->SetItem(0, token);
                oed_tuple->SetItem(1, ssr_oed.Encode());
            list->AddItem(new PyObjectEx(false, oed_tuple));
            if (cur->IsRing()) {
                isRing = true;
                ring->AddItem(new PyObjectEx(false, oed_tuple));
            }
        }
        if (isRing)
            list->AddItem(ring);
        data.probes = tuple;
        data.probePos = list;
        // there is *something* here where one of the positions is given as a nested list of objects
        /*
                      [PyString "pos"]
                      [PyList 6 items]
                        [PyObjectEx Type2]
                          [PyTuple 2 items]
                            [PyTuple 1 items]
                              [PyToken foo.Vector3]
                            [PyTuple 3 items]
                              [PyFloat 506169425920]
                              [PyFloat 948782891008]
                              [PyFloat 154119258112]
                        [PyList 3 items]
                          [PyObjectEx Type2]
                            [PyTuple 2 items]
                              [PyTuple 1 items]
                                [PyToken foo.Vector3]
                              [PyTuple 3 items]
                                [PyFloat 506169425920]
                                [PyFloat -555071897600]
                                [PyFloat 1636387389440]
                */
    } else {
        ScanResultPos ssr_oed;
            ssr_oed.x = probeVec.at(0)->GetPosition().x;
            ssr_oed.y = probeVec.at(0)->GetPosition().y;
            ssr_oed.z = probeVec.at(0)->GetPosition().z;
        PyToken* token = new PyToken("foo.Vector3");
        PyTuple* oed_tuple = new PyTuple(2);
            oed_tuple->SetItem(0, token);
            oed_tuple->SetItem(1, ssr_oed.Encode());
        data.probes = new PyInt(probeVec.at(0)->GetID());
        if (probeVec.at(0)->IsSphere())
            ; // placeholder.  no clue how to do this yet
        data.probePos = new PyObjectEx(false, oed_tuple);
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Scan::GetSignalData	(	SignalData &	data,
		std::vector< ProbeSE * > &	probeVec
	)

Todo:

make sure this 'reported' position is within probe boundary

Definition at line 580 of file Scan.cpp.

References _log, CalcProbeAngles(), SignalData::certainty, SignalData::deviation, EvE::max(), ONE_AU_IN_METERS, CosmicSignature::position, EvE::Trig::Rad2Deg(), SignalData::sig, CosmicSignature::sigID, CosmicSignature::sigName, CosmicSignature::sigStrength, Stat::sitesScanned, and sStatMgr.

Referenced by GetProbeDataForSig().

{
    // probeVec has only probes than are in range of a signal it can scan
    uint8 probeCount = probeVec.size();
    float probeMultiplier(0.0f);
    switch(probeCount) {
        //  new style...already calculated (in python) for 1 to 8 probes
        case 1: probeMultiplier = 0.25774312594204907; break;
        case 2: probeMultiplier = 0.5130245854773758; break;
        case 3: probeMultiplier = 0.7234132613571191; break;
        case 4: probeMultiplier = 0.8824741410676007; break;
        case 5: probeMultiplier = 0.9963325352118082; break;
        case 6: probeMultiplier = 1.0754155621393995; break;
        case 7: probeMultiplier = 1.1296251734489133; break;
        case 8: probeMultiplier = 1.1666968137637062; break;
    }

    GPoint point(data.sig.position);
    data.deviation = 0;
    float scanStr1(0), rangeMod1(0), dist1(0), scanStr2(0), rangeMod2(0), dist2(0), angleMod(0);
    if (probeCount == 1) {
        dist1 = probeVec.at(0)->GetPosition().distance(point);
        rangeMod1 = probeVec.at(0)->GetRangeModifier(dist1);
        scanStr1 = probeVec.at(0)->GetScanStrength();
        data.deviation = probeVec.at(0)->GetDeviation() *1.3;  // fudge a bit for single probe
        data.certainty = data.sig.sigStrength * (scanStr1 / rangeMod1) / 2;
        _log(SCAN__TRACE, "Scan::GetSignalData(1)  dist: %.3fAU, rangeMod: %.5f, scanStr: %.5f", \
                dist1 / ONE_AU_IN_METERS, rangeMod1, scanStr1);
    } else {
        /*  loop thru probes and get range mods and sigStrength for each.
         *  combine all probe's data to get good sum based on probe range and strength
         */
        int8 count(0), max(2);
        if (probeVec.at(0)->HasMaxSkill())
            max = 3;
        std::map<float, std::pair<ProbeSE*, ProbeSE*>> angleMap;     // angle, <probeSE1,probeSE2>
        CalcProbeAngles(point, probeVec, angleMap);    //determine probe angles to target
        float probeSig1(0), probeSig2(0);
        // reverse-iterate to use highest values first
        std::map<float, std::pair<ProbeSE*, ProbeSE*>>::reverse_iterator itr = angleMap.rbegin(), end = angleMap.rend();
        for (; itr != end; ++itr) {
            // we are using top 3 angle pairs of 2 probes/angle, which gives 6 total scans for str calc.
            // if player has signal acquisition and sensor linking both at l5, this will allow another pair of scan results
            if (count > max)
                break;
            angleMod = sin(itr->first / 2);      // get value between 0 and 1 (fuzzy logic as angle modifier)
            // get sigStr from first probe
            dist1 = itr->second.first->GetPosition().distance(point);
            rangeMod1 = itr->second.first->GetRangeModifier(dist1);
            scanStr1 = itr->second.first->GetScanStrength();
            probeSig1 = data.sig.sigStrength * angleMod * probeMultiplier * (scanStr1 / rangeMod1);
            data.certainty += probeSig1;
            // get sigStr from second probe
            dist2 = itr->second.second->GetPosition().distance(point);
            rangeMod2 = itr->second.second->GetRangeModifier(dist2);
            scanStr2 = itr->second.second->GetScanStrength();
            probeSig2 = data.sig.sigStrength * angleMod * probeMultiplier * (scanStr2 / rangeMod2);
            data.certainty += probeSig2;
            // get deviation from both probes
            data.deviation += itr->second.first->GetDeviation();
            data.deviation += itr->second.second->GetDeviation();
            _log(SCAN__TRACE, "Scan::GetSignalData(%u)  #%u - angle %.3f (P1 %u, P2 %u) - dist: %.3fAU, %.3fAU, rangeMod: %.5f, %.5f, scanStr: %.5f, %.5f, angleMod: %.4f, multiplier: %.5f, probeSig: %.5f, %.5f", \
                    probeCount, ++count, EvE::Trig::Rad2Deg(itr->first), itr->second.first->GetID(), itr->second.second->GetID(), dist1 /ONE_AU_IN_METERS, dist2 /ONE_AU_IN_METERS,\
                    rangeMod1, rangeMod2, scanStr1, scanStr2, angleMod, probeMultiplier, probeSig1, probeSig2);
        }
        // get average deviation from all probes
        data.deviation /= count *2;
    }
/*Results, and What They Mean

    Sphere: The result is somewhere in the sphere. One probe only has a hit and approximate range. You can get multiple probes with independent hits, it can be messy. This is the least accurate hit.
    Circle: Two probes have approximate distances. More accurate, and likely to yield better hits with more probes. Target anomaly is located near the circle.
    Two Dots: Three probes have distances, which narrows it down to between two possible locations. Likely to be more or less accurate, but beware of deviation. Target anomaly has been narrowed down to being near one of the dots.
    One Dot: Four or more probes can see the result. Once scan strength reaches 100%, the result will be warpable.
*/
    if ((data.certainty < 0.05) and (probeCount == 1)) { // set sphere
        probeVec.at(0)->SetSphere(true);
    } else if ((data.certainty < 0.08) and (probeCount == 2) ) {
        // set ring
        probeVec.at(0)->SetRing(true);
        probeVec.at(1)->SetRing(true);
    } else if (data.certainty > 0.99) {
        sStatMgr.Increment(Stat::sitesScanned);
    }

    // adjust deviation based on signal strength
    /*
    if (data.certainty < 0.8f)
        data.deviation *= (1 + (1 - data.certainty));
    else
        data.deviation *= (1 - data.certainty);
    */

    //point.MakeRandomPointOnSphereLayer(data.deviation /2, data.deviation);
    data.sig.position = point;

    _log(SCAN__TRACE, "Scan::GetSignalData() - certainty for signal %s(%s) is %.5f (sigStrength:%.5f) \n Deviation: %.0fm (%.3f AU)", \
            data.sig.sigName.c_str(), data.sig.sigID.c_str(), data.certainty, data.sig.sigStrength, data.deviation, (data.deviation / ONE_AU_IN_METERS));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Scan::ProbeScanResult

(

)

Definition at line 294 of file Scan.cpp.

References _log, SignalData::certainty, SignalData::deviation, PyRep::Dump(), AnomalyMgr::GetAnomalyList(), SystemManager::GetAnomMgr(), Client::GetName(), GetProbeDataForSig(), Client::GetShipID(), AnomalyMgr::GetSignatureList(), Client::GetSystemID(), m_activeProbeMap, m_client, m_system, NULL_ORIGIN(), CosmicSignature::position, SignalData::probePos, SignalData::probes, Client::SendNotification(), PyTuple::SetItem(), PyDict::SetItem(), SignalData::sig, Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

Referenced by ProcessScan().

{
    // this will use outline of above code, but be MUCH more complicated...
    _log(SCAN__TRACE, "Scan::ProbeScanResult()  for %s in system %u", m_client->GetName(), m_client->GetSystemID());

    PyList* resultList = new PyList();
    std::vector<CosmicSignature> sig, anom;

    // are anomalies shown in probe scan results?  config option?
    m_system->GetAnomMgr()->GetAnomalyList(anom);
    for (auto anoms : anom) {
        SystemScanResult ssr;
            ssr.typeID = anoms.sigTypeID;
            ssr.scanGroupID = anoms.scanGroupID;
            ssr.groupID = anoms.sigGroupID;
            ssr.strengthAttributeID = anoms.scanAttributeID;
            ssr.dungeonName = anoms.sigName;
            ssr.id = anoms.sigID;
            ssr.deviation = 0;     /* 0 for anomalies */
            ssr.degraded = false;
            ssr.probeID = new PyInt(m_client->GetShipID());
            ssr.certainty = anoms.sigStrength;
            ssr.pos = new PyToken("foo.Vector3"); //PyStatic.NewNone();
            /*  this is ship position first, then anomaly position
             *    [PyString "data"]
             *    [PyObjectEx Type2]
             *      [PyTuple 2 items]
             *        [PyTuple 1 items]
             *          [PyObjectEx Type2]
             *            [PyTuple 2 items]
             *              [PyTuple 1 items]
             *                [PyToken foo.Vector3]
             *              [PyTuple 3 items]
             *                [PyFloat 924428329391.783]
             *                [PyFloat 8194006649.63061]
             *                [PyFloat 165918840569.438]
             *        [PyTuple 3 items]
             *          [PyFloat 1231197245226]
             *          [PyFloat -146772910080]
             *          [PyFloat 111531171840]
             */
        ScanResultPos ssr_oed;
            ssr_oed.x = anoms.position.x;
            ssr_oed.y = anoms.position.y;
            ssr_oed.z = anoms.position.z;
        PyToken* token = new PyToken("foo.Vector3");
        PyTuple* oed_tuple = new PyTuple(2);
            oed_tuple->SetItem(0, token);
            oed_tuple->SetItem(1, ssr_oed.Encode());
        ssr.data = new PyObjectEx(false, oed_tuple);  // oed goes here
        resultList->AddItem(ssr.Encode());
    }

    m_system->GetAnomMgr()->GetSignatureList(sig);
    for (auto sigs : sig) {
        SignalData data = SignalData();
            data.sig = sigs;
            data.probes = nullptr;
            data.probePos = nullptr;
        if (GetProbeDataForSig(data)) {
            SystemScanResult ssr;
                ssr.id = sigs.sigID;
                ssr.dungeonName = sigs.sigName;
                ssr.typeID = sigs.sigTypeID;
                ssr.groupID = sigs.sigGroupID;
                ssr.scanGroupID = sigs.scanGroupID;
                ssr.strengthAttributeID = sigs.scanAttributeID;
                ssr.degraded = false;
                ssr.deviation = data.deviation; //deviation is the distance between the scan result shown on the map and the actual location of your target.
                ssr.certainty = data.certainty; // this is listed as "signal strength" in scan window
                ssr.probeID = data.probes;
                ssr.pos = data.probePos;
            ScanResultPos ssr_oed;
                ssr_oed.x = data.sig.position.x;
                ssr_oed.y = data.sig.position.y;
                ssr_oed.z = data.sig.position.z;
            PyToken* token = new PyToken("foo.Vector3");
            PyTuple* oed_tuple = new PyTuple(2);
                oed_tuple->SetItem(0, token);
                oed_tuple->SetItem(1, ssr_oed.Encode());
            ssr.data = new PyObjectEx(false, oed_tuple);  // oed goes here
            resultList->AddItem(ssr.Encode());
        }
    }

    GPoint pos(NULL_ORIGIN);
    PyDict* probeDict = new PyDict();
    for (auto cur : m_activeProbeMap) {
        // probe data here...
        ScanProbesDict spd;
        spd.expiry = cur.second->GetExpiryTime();
        spd.maxDeviation = cur.second->GetDeviation();
        pos = cur.second->GetPosition();
        ScanResultPos ssr_oed;
            ssr_oed.x = pos.x;
            ssr_oed.y = pos.y;
            ssr_oed.z = pos.z;
        PyToken* token = new PyToken("foo.Vector3");
        PyTuple* oed_tuple = new PyTuple(2);
            oed_tuple->SetItem(0, token);
            oed_tuple->SetItem(1, ssr_oed.Encode());
        spd.pos = new PyObjectEx(false, oed_tuple);  // oed goes here
        spd.destination = spd.pos;
        spd.probeID = cur.first;
        spd.state = cur.second->GetState();
        spd.rangeStep = cur.second->GetRangeStep();
        spd.scanRange = cur.second->GetScanRange();
        spd.scanStrength = cur.second->GetScanStrength();
        spd.typeID = cur.second->GetSelf()->typeID();
        probeDict->SetItem(new PyInt(cur.first), spd.Encode());
    }

    // this will be sigs that are no longer present in current scan range
    //  will have to keep previous list and compare with current list to populate this
    // may not be used.....testing
    PyList* absentList = new PyList();

    OnSystemScanStopped osssp;
        osssp.scanProbesDict = probeDict;
        osssp.systemScanResult = resultList;
        osssp.absentTargets = absentList;
    PyTuple* ev = osssp.Encode();
    ev->Dump(SCAN__RSPDUMP, "psr-    ");
    m_client->SendNotification("OnSystemScanStopped", "charid", &ev);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Scan::ProcessScan

(

bool

useProbe = false

)

Definition at line 56 of file Scan.cpp.

References _log, AttrScanSpeed, EvilNumber::get_uint32(), InventoryItem::GetAttribute(), Client::GetShip(), Probe::State::Idle, m_activeProbeMap, m_client, m_probeMap, m_probeScan, ProbeScanResult(), Probe::State::Scanning, Client::SetScanTimer(), ShipScanResult(), and SystemScanStarted().

Referenced by Client::ProcessClient().

{
    if (!useProbe) {
        ShipScanResult();
        return;
    }
    if (m_probeScan) {
        ProbeScanResult();
        m_probeScan = false;
        m_activeProbeMap.clear();
        return;
    }

    bool idle = true;
    uint16 ntime(0), duration = m_client->GetShip()->GetAttribute(AttrScanSpeed).get_uint32();
    if (duration < 1000)
        duration = 8000;    // 8s default probe scan time.
    for (auto cur : m_activeProbeMap) {
        if (cur.second->IsMoving()) {
            idle = false;
            ntime = cur.second->GetMoveTime();
            // this time isnt right (but very close).  need to really think it thru for correctness
            //  currrently, it will allow probes to hit 'idle' as scanning starts, or a few ms after.
            if (ntime > duration)       // flipped conditional
                duration = ntime;
        } else {
            cur.second->SendStateChange(Probe::State::Idle);
        }
    }
    if (idle) {
        m_probeScan = true;
        for (auto cur : m_activeProbeMap) {
            cur.second->SendStateChange(Probe::State::Scanning);
            cur.second->StartStateTimer(duration);
        }
        SystemScanStarted(duration);
    }
    _log(SCAN__TRACE, "ProcessScan() - probes - active:%u, total:%u, duration: %u, idle: %s", \
                m_activeProbeMap.size(), m_probeMap.size(), duration, idle?"true":"false");
    m_client->SetScanTimer(duration, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Scan::RemoveProbe

(

ProbeSE *

pProbe

)

Definition at line 51 of file Scan.cpp.

References SystemEntity::GetID(), and m_probeMap.

Referenced by ProbeSE::RemoveProbe(), and ProbeSE::~ProbeSE().

{
    m_probeMap.erase(pProbe->GetID());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Scan::RequestScans

(

PyDict *

dict

)

Definition at line 139 of file Scan.cpp.

References _log, args, PyRep::AsFloat(), PyRep::AsTuple(), AttrScanSpeed, PyDict::begin(), ProbeData::dest, PyDict::empty(), PyDict::end(), ProbeData::expiry, EvilNumber::get_uint32(), InventoryItem::GetAttribute(), Client::GetCharacterID(), GetFileTimeNow(), PyTuple::GetItem(), Client::GetName(), Client::GetShip(), Client::GetSystemName(), PyObjectEx::header(), if(), Probe::State::Inactive, PyRep::IntegerValueU32(), m_activeProbeMap, m_client, m_probeMap, ProbeData::rangeStep, ProbeData::scanRange, Client::SendNotification(), Client::SetScanTimer(), PyDict::size(), ProbeData::state, PyFloat::value(), Ga::GaVec3::x, Ga::GaVec3::y, and Ga::GaVec3::z.

                                    {
    uint16 duration = m_client->GetShip()->GetAttribute(AttrScanSpeed).get_uint32();
    if ((dict == nullptr) or dict->empty()) {
        _log(SCAN__MESSAGE, "Scan::RequestScans() called by %s in %s using ship scanner.", \
                m_client->GetName(), m_client->GetSystemName().c_str());

        OnSystemScanStarted ossst;
            ossst.timestamp = GetFileTimeNow();
            ossst.duration = duration;
            ossst.scanProbesDict = new PyDict();
        PyTuple* ev = ossst.Encode();
        m_client->SendNotification("OnSystemScanStarted", "charid", &ev);
        m_client->SetScanTimer(duration);
        return;
    }

    _log(SCAN__MESSAGE, "Scan::RequestScans() called by %s in %s using %u probes.",\
            m_client->GetName(), m_client->GetSystemName().c_str(), dict->size());

    uint32 probeID(0);
    PyDict::const_iterator cItr = dict->begin();
    for (; cItr != dict->end(); ++cItr) {
        // find probe in map....
        probeID = PyRep::IntegerValueU32(cItr->first);  // key
        std::map<uint32, ProbeSE*>::iterator pItr = m_probeMap.find(probeID);
        if (pItr == m_probeMap.end()) {
            _log(SCAN__ERROR, "Probe %u wasnt found in the probeMap for %s(%u)", \
                    probeID, m_client->GetName(), m_client->GetCharacterID());
            continue;  // make error here?
        }
        std::map<uint32, ProbeSE*>::iterator aItr = m_activeProbeMap.find(probeID);
        if (aItr == m_activeProbeMap.end())
            m_activeProbeMap[probeID] = pItr->second;

        Call_ProbeDataObj args;
        if (!args.Decode(cItr->second)) { // value
            _log(SERVICE__ERROR, "Scan::RequestScans::DecodeProbeData: Failed to decode arguments.");
            // make error here
            continue;
        }

        ProbeData data = ProbeData();
            data.state = args.state;    // do we need this?
            data.expiry = args.expiry;
            data.rangeStep = args.rangeStep;
            data.scanRange = args.scanRange;
        // set probe target
        PyObjectEx* obj = args.destination->AsObjectEx();
        PyTuple* dest = obj->header()->AsTuple()->GetItem(1)->AsTuple();
            data.dest.x = dest->GetItem(0)->AsFloat()->value();
            data.dest.y = dest->GetItem(1)->AsFloat()->value();
            data.dest.z = dest->GetItem(2)->AsFloat()->value();
        pItr->second->UpdateProbe(data);
    }

    // loop thru probe maps to see if any are disabled, then set status as 'inactive' to omit from tracking
    for (auto cur : m_probeMap) {
        std::map<uint32, ProbeSE*>::iterator itr = m_activeProbeMap.find(cur.first);
        if (itr == m_activeProbeMap.end())
            cur.second->SetState(Probe::State::Inactive);
    }

    m_client->SetScanTimer(duration, true);
}

Here is the call graph for this function:

void Scan::ScanStart ( )

protected

Definition at line 787 of file Scan.cpp.

{

}

void Scan::ShipScanResult

(

)

Todo:

see client code to verify what it expects, and what it can calculate

Definition at line 245 of file Scan.cpp.

References PyList::AddItem(), PyRep::Dump(), SystemManager::GetAllEntities(), AnomalyMgr::GetAnomalyList(), SystemManager::GetAnomMgr(), SystemManager::GetID(), Client::GetShipID(), Client::IsShowall(), m_client, m_system, PyStatic, sBubbleMgr, Client::SendNotification(), and PyTuple::SetItem().

Referenced by ProcessScan().

                          {
    //  WORKING CODE...DONT FUCK WITH THIS!!  -allan 11Dec15
    // client scan data found in EVE_Scanning.h
    std::vector<CosmicSignature> anom;
    if (m_client->IsShowall()) {
        m_system->GetAllEntities(anom);
        // bubble centers only populate when bubble markers are enabled.
        sBubbleMgr.GetBubbleCenterMarkers(m_system->GetID(), anom);
    } else {
        m_system->GetAnomMgr()->GetAnomalyList(anom);
    }

    PyList* resultList = new PyList();
    // NOTE. cannot scan pos, wrecks, ships, mission sites, or escalations.  they DO have sigIDs, and can get to type (25%), but no farther
    for (auto anoms : anom) {
        SystemScanResult ssr;
            ssr.typeID = anoms.sigTypeID;
            ssr.scanGroupID = anoms.scanGroupID;
            ssr.groupID = anoms.sigGroupID;
            ssr.strengthAttributeID = anoms.scanAttributeID;
            ssr.dungeonName = anoms.sigName;
            ssr.id = anoms.sigID;
            ssr.deviation = 0;     /* for scan probes */
            ssr.degraded = false;  /* dunno what this does.  have only seen 'false' in packets */
            ssr.probeID = new PyInt(m_client->GetShipID());
            ssr.certainty = anoms.sigStrength;
            ssr.pos = PyStatic.NewNone();
        ScanResultPos ssr_oed;
            ssr_oed.x = anoms.position.x;
            ssr_oed.y = anoms.position.y;
            ssr_oed.z = anoms.position.z;
        PyTuple* oed_tuple = new PyTuple(2);
            oed_tuple->SetItem(0, new PyToken("foo.Vector3"));
            oed_tuple->SetItem(1, ssr_oed.Encode());
        ssr.data = new PyObjectEx(false, oed_tuple);  // oed goes here
        resultList->AddItem(ssr.Encode());
    }

    OnSystemScanStopped osss;
        osss.systemScanResult = resultList;
        // probeDict and absentTargets are both empty when using ship sensors to scan.
        osss.scanProbesDict = new PyDict();
        osss.absentTargets = new PyList();
    PyTuple* ev = osss.Encode();
    ev->Dump(SCAN__RSPDUMP, "ssr-    ");
    m_client->SendNotification("OnSystemScanStopped", "charid", &ev);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Scan::SurveyScan ( )

protected

Definition at line 792 of file Scan.cpp.

                      {
    /*
     *
     *                      [PyString "OnSpecialFX"]
     *                      [PyTuple 14 items]
     *                        [PyIntegerVar 1002331681462]
     *                        [PyIntegerVar 1002332233248]
     *                        [PyInt 444]
     *                        [PyNone]
     *                        [PyNone]
     *                        [PyList 0 items]
     *                        [PyString "effects.SurveyScan"]
     *                        [PyBool False]
     *                        [PyInt 1]
     *                        [PyInt 1]
     *                        [PyFloat 4250]
     *                        [PyInt 0]
     *                        [PyIntegerVar 129509430135552798]
     *                        [PyNone]
     *
     */
}

void Scan::SystemScanStarted

(

uint16

duration

)

Definition at line 204 of file Scan.cpp.

References _log, PyRep::Dump(), GetFileTimeNow(), Client::GetName(), Client::GetSystemID(), m_activeProbeMap, m_client, NULL_ORIGIN(), PyIncRef, Client::SendNotification(), PyTuple::SetItem(), and PyDict::SetItem().

Referenced by ProcessScan().

{
    _log(SCAN__TRACE, "Scan::SystemScanStarted()  for %s in system %u", m_client->GetName(), m_client->GetSystemID());

    GPoint pos(NULL_ORIGIN);
    PyDict* probeDict = new PyDict();
    for (auto cur : m_activeProbeMap) {
        // probe data here...
        ScanProbesDict spd;
            spd.expiry = cur.second->GetExpiryTime();
            spd.maxDeviation = cur.second->GetDeviation();
            spd.probeID = cur.first;
            spd.state = cur.second->GetState();
            spd.rangeStep = cur.second->GetRangeStep();
            spd.scanRange = cur.second->GetScanRange();
            spd.scanStrength = cur.second->GetScanStrength();
            spd.typeID = cur.second->GetSelf()->typeID();
        pos = cur.second->GetPosition();
        ScanResultPos srp;
            srp.x = pos.x;
            srp.y = pos.y;
            srp.z = pos.z;
        PyToken* token = new PyToken("foo.Vector3");
        PyTuple* oed_tuple = new PyTuple(2);
            oed_tuple->SetItem(0, token);
            oed_tuple->SetItem(1, srp.Encode());
        spd.pos = new PyObjectEx(false, oed_tuple);  // oed goes here
        PyIncRef(spd.pos);
        spd.destination = spd.pos;
        probeDict->SetItem(new PyInt(cur.first), spd.Encode());
    }

    OnSystemScanStarted ossst;
        ossst.timestamp = GetFileTimeNow();
        ossst.duration = duration;
        ossst.scanProbesDict = probeDict;
    PyTuple* ev = ossst.Encode();
    ev->Dump(SCAN__RSPDUMP, "sss-    ");
    m_client->SendNotification("OnSystemScanStarted", "charid", &ev, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::map<uint32, ProbeSE*> Scan::m_activeProbeMap

private

Definition at line 72 of file Scan.h.

Referenced by GetProbeDataForSig(), ProbeScanResult(), ProcessScan(), RequestScans(), Scan(), and SystemScanStarted().

Client* Scan::m_client

private

Definition at line 64 of file Scan.h.

Referenced by ConeScan(), ProbeScanResult(), ProcessScan(), RequestScans(), ShipScanResult(), and SystemScanStarted().

ManagerDB* Scan::m_db

private

Definition at line 63 of file Scan.h.

std::map<uint32, ProbeSE*> Scan::m_probeMap

private

Definition at line 71 of file Scan.h.

Referenced by AddProbe(), GetProbeCount(), ProcessScan(), RemoveProbe(), RequestScans(), and Scan().

bool Scan::m_probeScan

private

Definition at line 69 of file Scan.h.

Referenced by ProcessScan(), and Scan().

SystemManager* Scan::m_system

private

Definition at line 65 of file Scan.h.

Referenced by GetProbeDataForSig(), ProbeScanResult(), and ShipScanResult().

---

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

• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/exploration/Scan.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-server/exploration/Scan.cpp