ChooseTargetClass< numTuple > Class Template Reference

Public Member Functions
	ChooseTargetClass ()
void	init (FireAt *fireat, Unit *un, float gunrange, vector< TurretBin > *tbin, const StaticTuple< float, numTuple > &innermaxrange, char maxrolepriority, int maxtargets)
bool	acquire (Unit *un, float distance)
bool	ShouldTargetUnit (Unit *un, float distance)

Public Attributes
Unit *	mytarg

Detailed Description

template<size_t numTuple>
class ChooseTargetClass< numTuple >

Definition at line 303 of file fire.cpp.

Constructor & Destructor Documentation

template<size_t numTuple>

ChooseTargetClass< numTuple >::ChooseTargetClass ( )

inline

Definition at line 321 of file fire.cpp.

{}

Member Function Documentation

template<size_t numTuple>

bool ChooseTargetClass< numTuple >::acquire ( Unit *  un, float  distance  )

inline

Definition at line 353 of file fire.cpp.

References Collidable::getKey(), i, Unit::location, and Unit::UNIT_ONLY.

    {
        double unkey     = un->location[Unit::UNIT_ONLY]->getKey();
        bool   lesscheck = unkey < maxinnerrangeless[0];
        bool   morecheck = unkey > maxinnerrangemore[0];
        if (reachedMore == false || reachedLess == false) {
            if (lesscheck || morecheck) {
                if (lesscheck)
                    reachedLess = true;
                if (morecheck)
                    reachedMore = true;
                if (mytarg && rolepriority < maxrolepriority) {
                    return false;
                } else if (reachedLess == true && reachedMore == true) {
                    for (size_t i = 1; i < numTuple; ++i)
                        if (unkey > maxinnerrangeless[i] && unkey < maxinnerrangemore[i]) {
                            maxinnerrangeless[0] = maxinnerrangeless[i];
                            maxinnerrangemore[0] = maxinnerrangemore[i];
                            reachedLess = false;
                            reachedMore = false;
                        }
                }
            }
        }
        return ShouldTargetUnit( un, distance );
    }

template<size_t numTuple>

void ChooseTargetClass< numTuple >::init ( FireAt *  fireat, Unit *  un, float  gunrange, vector< TurretBin > *  tbin, const StaticTuple< float, numTuple > &  innermaxrange, char  maxrolepriority, int  maxtargets  )

inline

Definition at line 322 of file fire.cpp.

References Collidable::getKey(), UniverseUtil::getUnitByPtr(), i, is_null(), Unit::location, Unit::owner, and Unit::UNIT_ONLY.

    {
        this->fireat = fireat;
        this->tbin   = tbin;
        this->parent = un;
        this->parentparent = un->owner ? UniverseUtil::getUnitByPtr( un->owner, un, false ) : 0;
        mytarg = NULL;
        double currad = 0;
        if ( !is_null( un->location[Unit::UNIT_ONLY] ) )
            currad = un->location[Unit::UNIT_ONLY]->getKey();
        for (size_t i = 0; i < numTuple; ++i) {
            double tmpless = currad-innermaxrange[i];
            double tmpmore = currad+innermaxrange[i];
            this->maxinnerrangeless[i] = tmpless;
            this->maxinnerrangemore[i] = tmpmore;
        }
        this->maxrolepriority = maxrolepriority; //max priority that will allow gun range to be ok
        reachedMore        = false;
        reachedLess        = false;
        this->priority     = -1;
        this->rolepriority = 31;
        this->gunrange     = gunrange;
        this->numtargets   = 0;
        this->maxtargets   = maxtargets;
    }

template<size_t numTuple>

bool ChooseTargetClass< numTuple >::ShouldTargetUnit ( Unit *  un, float  distance  )

inline

Definition at line 379 of file fire.cpp.

References Unit::CloakVisible(), ROLES::getPriority(), i, k, Priority(), and Unit::unitRole().

    {
        if (un->CloakVisible() > .8) {
            float rangetotarget = distance;
            float rel0  = parent->getRelation( un );
            float rel[] = {
                rel0         //not initialized until after array
                , (parentparent ? parentparent->getRelation( un ) : rel0)           //not initialized till after array
            };
            float relationship = rel0;
            for (unsigned int i = 1; i < sizeof (rel)/sizeof (*rel); i++)
                if (rel[i] < relationship)
                    relationship = rel[i];
            char  rp  = 31;
            float tmp = Priority( parent, un, gunrange, rangetotarget, relationship, &rp );
            if (tmp > priority) {
                mytarg = un;
                priority = tmp;
                rolepriority = rp;
            }
            for (vector< TurretBin >::iterator k = tbin->begin(); k != tbin->end(); ++k) {
                if (rangetotarget > k->maxrange)
                    break;
                const char tprior = ROLES::getPriority( k->turret[0].tur->attackPreference() )[un->unitRole()];
                if (relationship < 0) {
                    if (tprior < 16) {
                        k->listOfTargets[0].push_back( TargetAndRange( un, rangetotarget, relationship ) );
                        numtargets++;
                    } else if (tprior < 31) {
                        k->listOfTargets[1].push_back( TargetAndRange( un, rangetotarget, relationship ) );
                        numtargets++;
                    }
                }
            }
        }
        return (maxtargets == 0) || (numtargets < maxtargets);
    }

Member Data Documentation

template<size_t numTuple>

Unit* ChooseTargetClass< numTuple >::mytarg

Definition at line 320 of file fire.cpp.

---

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

• src/cmd/ai/fire.cpp