#include "fire.h"
#include "flybywire.h"
#include "navigation.h"
#include "cmd/planet_generic.h"
#include "config_xml.h"
#include "vs_globals.h"
#include "cmd/unit_util.h"
#include "cmd/script/flightgroup.h"
#include "cmd/role_bitmask.h"
#include "cmd/ai/communication.h"
#include "universe_util.h"
#include <algorithm>
#include "cmd/unit_find.h"
#include "vs_random.h"
#include "lin_time.h"
#include "cmd/pilot.h"

Classes
struct	TargetAndRange

struct	RangeSortedTurrets

struct	TurretBin

class	StaticTuple< T, n >

class	ChooseTargetClass< numTuple >

Functions
static bool	NoDockWithClear ()

Unit *	getAtmospheric (Unit *targ)

bool	RequestClearence (Unit parent, Unit targ, unsigned char sex)

bool	CanFaceTarget (Unit su, Unit targ, const Matrix &matrix)

void	AssignTBin (Unit *su, vector< TurretBin > &tbin)

float	Priority (Unit me, Unit targ, float gunrange, float rangetotarget, float relationship, char *rolepriority)

float	Priority (Unit me, Unit targ, float gunrange, float rangetotarget, float relationship)

unsigned int	FireBitmask (Unit *parent, bool shouldfire, bool firemissile)

Variables
int	numprocessed

double	targetpick

VSRandom	targrand (time(NULL))

int	numpolled [2] = {0, 0}

int	prevpollindex [2] = {10000, 10000}

int	pollindex [2] = {1, 1}

Function Documentation

void AssignTBin	(	Unit *	su,
		vector< TurretBin > &	tbin
	)

Definition at line 207 of file fire.cpp.

References Unit::attackPreference(), Unit::getAverageGunSpeed(), Unit::getSubUnits(), and i.

Referenced by Orders::FireAt::ChooseTargets().

 {
     unsigned int bnum = 0;
     for (; bnum < tbin.size(); bnum++)
         if ( su->attackPreference() == tbin[bnum].turret[0].tur->attackPreference() )
             break;
     if ( bnum >= tbin.size() )
         tbin.push_back( TurretBin() );
     float gspeed, grange, mrange;
     grange = FLT_MAX;
     su->getAverageGunSpeed( gspeed, grange, mrange );
     {
         float ggspeed, ggrange, mmrange;
         Unit *ssu;
         for (un_iter i = su->getSubUnits(); (ssu = *i) != NULL; ++i) {
             ssu->getAverageGunSpeed( ggspeed, ggrange, mmrange );
             if (ggspeed > gspeed) gspeed = ggspeed;
             if (ggrange > grange) grange = ggrange;
             if (mmrange > mrange) mrange = mmrange;
         }
     }
     if (tbin[bnum].maxrange < grange)
         tbin[bnum].maxrange = grange;
     tbin[bnum].turret.push_back( RangeSortedTurrets( su, grange ) );
 }

bool CanFaceTarget	(	Unit *	su,
		Unit *	targ,
		const Matrix &	matrix
	)

Definition at line 77 of file fire.cpp.

References Unit::cumulative_transformation_matrix, Unit::getSubUnits(), i, Unit::Limits::limitmin, Unit::Limits(), Unit::Position(), QVector, Unit::Limits::structurelimits, TransformNormal(), and Vector.

Referenced by TurretBin::AssignTargets().

 {
     return true;
 
     float limitmin = su->Limits().limitmin;
     if (limitmin > -.99) {
         QVector pos   = ( targ->Position()-su->Position() ).Normalize();
         QVector pnorm = pos.Cast();
         Vector  structurelimits = su->Limits().structurelimits;
         Vector  worldlimit = TransformNormal( matrix, structurelimits );
         if (pnorm.Dot( worldlimit ) < limitmin)
             return false;
     }
     Unit *ssu;
     for (un_iter i = su->getSubUnits();
          (ssu = *i) != NULL;
          ++i)
         if ( !CanFaceTarget( ssu, targ, su->cumulative_transformation_matrix ) )
             return false;
     return true;
 }

unsigned int FireBitmask	(	Unit *	parent,
		bool	shouldfire,
		bool	firemissile
	)

Definition at line 639 of file fire.cpp.

References ROLES::EVERYTHING_ELSE, ROLES::FIRE_GUNS, ROLES::FIRE_MISSILES, ROLES::FIRE_ONLY_AUTOTRACKERS, VegaConfig::getVariable(), XMLSupport::parse_bool(), Unit::Target(), Unit::unitRole(), and vs_config.

Referenced by Orders::TurretAI::Execute(), and Orders::FireAt::FireWeapons().

 {
     unsigned int firebitm = ROLES::EVERYTHING_ELSE;
     Unit *un = parent->Target();
     if (un) {
         firebitm = ( 1<<un->unitRole() );
 
         static bool AlwaysFireAutotrackers =
             XMLSupport::parse_bool( vs_config->getVariable( "AI", "AlwaysFireAutotrackers", "true" ) );
         if (shouldfire)
             firebitm |= ROLES::FIRE_GUNS;
         if (AlwaysFireAutotrackers && !shouldfire) {
             firebitm |= ROLES::FIRE_GUNS;
             firebitm |= ROLES::FIRE_ONLY_AUTOTRACKERS;
         }
         if (firemissile)
             firebitm = ROLES::FIRE_MISSILES;              //stops guns
     }
     return firebitm;
 }

Unit* getAtmospheric ( Unit * targ)

Definition at line 29 of file fire.cpp.

References _Universe, Universe::activeStarSystem(), UnitCollection::createIterator(), StarSystem::getUnitList(), i, Unit::isUnit(), Magnitude(), PLANETPTR, Unit::Position(), and Unit::rSize().

Referenced by RequestClearence().

 {
     if (targ) {
         Unit *un;
         for (un_iter i = _Universe->activeStarSystem()->getUnitList().createIterator();
              (un = *i) != NULL;
              ++i)
             if (un->isUnit() == PLANETPTR) {
                 if ( ( targ->Position()-un->Position() ).Magnitude() < targ->rSize()*.5 )
                     if ( !( ( (Planet*) un )->isAtmospheric() ) )
                         return un;
             }
     }
     return NULL;
 }

static bool NoDockWithClear ( )

static

Definition at line 21 of file fire.cpp.

References VegaConfig::getVariable(), XMLSupport::parse_bool(), and vs_config.

Referenced by RequestClearence().

 {
     static bool nodockwithclear = XMLSupport::parse_bool( vs_config->getVariable( "physics", "dock_with_clear_planets", "true" ) );
     return nodockwithclear;
 }

float Priority	(	Unit *	me,
		Unit *	targ,
		float	gunrange,
		float	rangetotarget,
		float	relationship,
		char *	rolepriority
	)

Definition at line 233 of file fire.cpp.

References Unit::attackPreference(), float, Unit::GetHull(), Unit::GetMass(), ROLES::getPriority(), VegaConfig::getVariable(), Unit::GetVelocity(), XMLSupport::parse_float(), Unit::Position(), Unit::Target(), Unit::Threat(), Unit::unitRole(), Vector, and vs_config.

Referenced by Priority(), and ChooseTargetClass< numTuple >::ShouldTargetUnit().

 {
     if (relationship >= 0)
         return -1;
     if (targ->GetHull() < 0)
         return -1;
     *rolepriority = ROLES::getPriority( me->attackPreference() )[targ->unitRole()];     //number btw 0 and 31 higher better
     char invrolepriority = 31-*rolepriority;
     if (invrolepriority <= 0)
         return -1;
     if (rangetotarget < 1 && rangetotarget > -1000)
         rangetotarget = 1;
     else
         rangetotarget = fabs( rangetotarget );
     if (rangetotarget < .5*gunrange)
         rangetotarget = .5*gunrange;
     if (gunrange <= 0) {
         static float mountless_gunrange =
             XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "MountlessGunRange", "300000000" ) );
         gunrange = mountless_gunrange;
     }     //probably a mountless capship. 50000 is chosen arbitrarily
     float inertial_priority = 0;
     {
         static float mass_inertial_priority_cutoff =
             XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "MassInertialPriorityCutoff", "5000" ) );
         if (me->GetMass() > mass_inertial_priority_cutoff) {
             static float mass_inertial_priority_scale =
                 XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "MassInertialPriorityScale", ".0000001" ) );
             Vector normv( me->GetVelocity() );
             float  Speed     = me->GetVelocity().Magnitude();
             normv *= Speed ? 1.0f/Speed : 1.0f;
             Vector ourToThem = targ->Position()-me->Position();
             ourToThem.Normalize();
             inertial_priority = mass_inertial_priority_scale*( .5+.5*( normv.Dot( ourToThem ) ) )*me->GetMass()*Speed;
         }
     }
     static float threat_weight = XMLSupport::parse_float( vs_config->getVariable( "AI", "Targetting", "ThreatWeight", ".5" ) );
     float threat_priority  = (me->Threat() == targ) ? threat_weight : 0;
     threat_priority += (targ->Target() == me) ? threat_weight : 0;
     float role_priority01  = ( (float) *rolepriority )/31.;
     float range_priority01 = .5*gunrange/rangetotarget;     //number between 0 and 1 for most ships 1 is best
     return range_priority01*role_priority01+inertial_priority+threat_priority;
 }

float Priority	(	Unit *	me,
		Unit *	targ,
		float	gunrange,
		float	rangetotarget,
		float	relationship
	)

Definition at line 277 of file fire.cpp.

References Priority().

 {
     char rolepriority = 0;
     return Priority( me, targ, gunrange, rangetotarget, relationship, &rolepriority );
 }

bool RequestClearence	(	Unit *	parent,
		Unit *	targ,
		unsigned char	sex
	)

Definition at line 45 of file fire.cpp.

References c, Order::Communicate(), Unit::DockingPortLocations(), CommunicationMessage::fsm, Unit::getAIState(), getAtmospheric(), FSM::GetRequestLandNode(), Unit::isUnit(), NoDockWithClear(), PLANETPTR, CommunicationMessage::SetCurrentState(), and Unit::Target().

Referenced by Cockpit::Update().

 {
     if ( !targ->DockingPortLocations().size() )
         return false;
     if (targ->isUnit() == PLANETPTR) {
         if ( ( (Planet*) targ )->isAtmospheric() && NoDockWithClear() ) {
             targ = getAtmospheric( targ );
             if (!targ)
                 return false;
             parent->Target( targ );
         }
     }
     CommunicationMessage c( parent, targ, NULL, sex );
     c.SetCurrentState( c.fsm->GetRequestLandNode(), NULL, sex );
     Order *o = targ->getAIState();
     if (o)
         o->Communicate( c );
     return true;
 }