#include <missile_generic.h>

Inheritance diagram for Missile:

Public Member Functions
void	Discharge ()

virtual enum clsptr	isUnit () const

virtual void	Kill (bool eraseFromSave=true)

virtual void	reactToCollision (Unit *smaller, const QVector &biglocation, const Vector &bignormal, const QVector &smalllocation, const Vector &smallnormal, float dist)

virtual void	UpdatePhysics2 (const Transformation &trans, const Transformation &old_physical_state, const Vector &accel, float difficulty, const Matrix &transmat, const Vector &CumulativeVelocity, bool ResolveLast, UnitCollection *uc=NULL)

Public Member Functions inherited from Unit
	Unit (bool kill)

void	Kill ()

bool	Killed ()

void	Ref ()

void	UnRef ()

	Unit ()

	Unit (int dummy)

	Unit (std::vector< Mesh * > &meshes, bool Subunit, int faction)

	Unit (const char filename, bool SubUnit, int faction, std::string customizedUnit=std::string(""), Flightgroup flightgroup=NULL, int fg_subnumber=0, std::string *netxml=NULL)

void	Init ()

void	Init (const char filename, bool SubUnit, int faction, std::string customizedUnit=std::string(""), Flightgroup flightgroup=NULL, int fg_subnumber=0, std::string *netxml=NULL)

void	LoadRow (class CSVRow &row, std::string unitMod, std::string *netxml=NULL)

virtual	~Unit ()

void	SetNetworkMode (bool mode=true)

ObjSerial	GetSerial () const

void	SetSerial (ObjSerial)

void	BackupState ()

bool	UpgradeSubUnitsWithFactory (const Unit up, int subunitoffset, bool touchme, bool downgrade, int &numave, double &percentage, Unit (*createupgradesubunit)(std::string s, int faction))

virtual bool	UpgradeSubUnits (const Unit *up, int subunitoffset, bool touchme, bool downgrade, int &numave, double &percentage)

bool	UpgradeMounts (const Unit up, int subunitoffset, bool touchme, bool downgrade, int &numave, const Unit templ, double &percentage)

un_iter	getSubUnits ()

un_kiter	viewSubUnits () const

bool	isSubUnit () const

void	setFaceCamera ()

bool	UpAndDownGrade (const Unit up, const Unit templ, int mountoffset, int subunitoffset, bool touchme, bool downgrade, int additive, bool forcetransaction, double &percentage, const Unit *downgrade_min, bool force_change_on_nothing, bool gen_downgrade_list)

void	ImportPartList (const std::string &category, float price, float pricedev, float quantity, float quantdev)

int	GetNumMounts () const

void	ClearMounts ()

virtual void	UpgradeInterface (Unit *base)

bool	canUpgrade (const Unit upgrador, int mountoffset, int subunitoffset, int additive, bool force, double &percentage, const Unit templ=NULL, bool force_change_on_nothing=false, bool gen_downgrade_list=true)

bool	Upgrade (const Unit upgrador, int mountoffset, int subunitoffset, int additive, bool force, double &percentage, const Unit templ=NULL, bool force_change_on_nothing=false, bool gen_downgrade_list=true)

int	RepairCost ()

int	RepairUpgrade ()

bool	RepairUpgradeCargo (Cargo item, Unit baseUnit, float *credits)

Vector	MountPercentOperational (int whichmount)

bool	ReduceToTemplate ()

virtual double	Upgrade (const std::string &file, int mountoffset, int subunitoffset, bool force, bool loop_through_mounts)

bool	canDowngrade (const Unit downgradeor, int mountoffset, int subunitoffset, double &percentage, const Unit downgradelimit, bool gen_downgrade_list=true)

bool	Downgrade (const Unit downgradeor, int mountoffset, int subunitoffset, double &percentage, const Unit downgradelimit, bool gen_downgrade_list=true)

unsigned	attackPreference () const

void	attackPreference (unsigned char)

unsigned	unitRole () const

void	unitRole (unsigned char)

void	setCombatRole (const std::string &s)

const std::string &	getCombatRole () const

const std::string &	getUnitRole () const

void	setUnitRole (const std::string &s)

const std::string &	getAttackPreference () const

void	setAttackPreference (const std::string &s)

void	DamageRandSys (float dam, const Vector &vec, float randum=1, float degrees=1)

void	SetNebula (Nebula *)

Nebula *	GetNebula () const

const std::string &	getCockpit () const

class Cockpit *	GetVelocityDifficultyMult (float &) const

void	RemoveFromSystem ()

void	RequestPhysics ()

bool	InCorrectStarSystem (StarSystem *)

virtual int	nummesh () const

virtual void	Split (int level)

virtual void	addHalo (const char *filename, const QVector &loc, const Vector &size, const GFXColor &col, std::string halo_type, float activation)

std::vector< Mesh * >	StealMeshes ()

virtual bool	Explode (bool draw, float timeit)

void	Destroy ()

virtual void	Draw (const Transformation &quat=identity_transformation, const Matrix &m=identity_matrix)

virtual void	DrawNow (const Matrix &m=identity_matrix, float lod=1000000000)

virtual void	UpdateHudMatrix (int whichcam)

virtual VSSprite *	getHudImage () const

virtual void	applyTechniqueOverrides (const std::map< std::string, std::string > &overrides)

const std::vector< std::string > &	GetDestinations () const

void	AddDestination (const std::string &)

void	SwitchCombatFlightMode ()

bool	CombatMode ()

virtual bool	TransferUnitToSystem (StarSystem *NewSystem)

virtual bool	TransferUnitToSystem (unsigned int whichJumpQueue, class StarSystem *&previouslyActiveStarSystem, bool DoSightAndSound)

StarSystem *	getStarSystem ()

const StarSystem *	getStarSystem () const

const UnitJump &	GetJumpStatus () const

float	CourseDeviation (const Vector &OriginalCourse, const Vector &FinalCourse) const

Computer &	GetComputerData ()

const Computer &	ViewComputerData () const

void	ActivateJumpDrive (int destination=0)

void	DeactivateJumpDrive ()

void	beginElement (const std::string &name, const XMLSupport::AttributeList &attributes)

void	endElement (const std::string &name)

void	WriteUnit (const char *modificationname="")

std::string	WriteUnitString ()

void	LoadXML (const char filename, const char unitModifications="", std::string *xmlbuffer=NULL)

void	LoadXML (VSFileSystem::VSFile &f, const char unitModifications="", std::string xmlbuffer=NULL)

bool	AutoPilotToErrorMessage (Unit *un, bool automaticenergyrealloc, std::string &failuremessage, int recursive_level=2)

bool	AutoPilotTo (Unit *un, bool automaticenergyrealloc)

Vector	LocalCoordinates (Unit *un) const

float	CloakVisible () const

virtual void	Cloak (bool cloak)

void	Kill (bool eraseFromSave=true, bool quitting=false)

bool	Killed () const

bool	IsExploding () const

float	ExplodingProgress () const

float	AfterburnData () const

void	SetAfterBurn (float aft)

float	FuelData () const

float	WarpCapData () const

void	SetFuel (float f)

float	EnergyRechargeData () const

void	SetEnergyRecharge (float enrech)

void	SetMaxEnergy (float maxen)

float	MaxEnergyData () const

float	ShieldRechargeData () const

float	EnergyData () const

float	WarpEnergyData () const

float	GetWarpEnergy () const

void	DecreaseWarpEnergy (bool insystem, float time=1.0f)

void	IncreaseWarpEnergy (bool insystem, float time=1.0f)

bool	RefillWarpEnergy ()

float	rSize () const

QVector	Position () const

const Matrix &	GetTransformation () const

QVector	LocalPosition () const

void	SetPosition (const QVector &pos)

void	SetCurPosition (const QVector &pos)
	Sets the cumulative transformation matrix's position...for setting up to be out in the middle of nowhere. More...

void	SetPosAndCumPos (const QVector &pos)

void	SetVisible (bool isvis)

void	SetAllVisible (bool isvis)

void	SetGlowVisible (bool isvis)

void	Rotate (const Vector &axis)

void	FireEngines (const Vector &Direction, float FuelSpeed, float FMass)

void	ApplyForce (const Vector &Vforce)

void	ApplyLocalForce (const Vector &Vforce)

void	Accelerate (const Vector &Vforce)

void	ApplyTorque (const Vector &Vforce, const QVector &Location)

void	ApplyLocalTorque (const Vector &Vforce, const Vector &Location)

void	ApplyBalancedLocalTorque (const Vector &Vforce, const Vector &Location)

void	ApplyLocalTorque (const Vector &torque)

float	ApplyLocalDamage (const Vector &pnt, const Vector &normal, float amt, Unit *affectedSubUnit, const GFXColor &, float phasedamage=0)

void	ApplyNetDamage (Vector &pnt, Vector &normal, float amt, float ppercentage, float spercentage, GFXColor &color)

void	ApplyDamage (const Vector &pnt, const Vector &normal, float amt, Unit affectedSubUnit, const GFXColor &, void ownerDoNotDereference, float phasedamage=0)

void	LightShields (const Vector &pnt, const Vector &normal, float amt, const GFXColor &color)

float	DealDamageToHullReturnArmor (const Vector &pnt, float Damage, float *&targ)

virtual void	ArmorDamageSound (const Vector &pnt)

virtual void	HullDamageSound (const Vector &pnt)

float	DealDamageToHull (const Vector &pnt, float Damage)

Vector	ClampThrust (const Vector &thrust, bool afterburn)

Vector	MaxThrust (const Vector &thrust)

virtual void	Thrust (const Vector &amt, bool afterburn=false)

void	LateralThrust (float amt)

void	VerticalThrust (float amt)

void	LongitudinalThrust (float amt)

Vector	ClampVelocity (const Vector &velocity, const bool afterburn)

Vector	ClampAngVel (const Vector &vel)

Vector	ClampTorque (const Vector &torque)

Vector	MaxTorque (const Vector &torque)

void	YawTorque (float amt)

void	PitchTorque (float amt)

void	RollTorque (float amt)

void	Repair ()

void	UpdatePhysics (const Transformation &trans, const Matrix &transmat, const Vector &CumulativeVelocity, bool ResolveLast, UnitCollection uc, Unit superunit)

virtual void	UpdateSubunitPhysics (const Transformation &trans, const Matrix &transmat, const Vector &CumulativeVelocity, bool ResolveLast, UnitCollection uc, Unit superunit)

virtual void	UpdateSubunitPhysics (Unit subunit, const Transformation &trans, const Matrix &transmat, const Vector &CumulativeVelocity, bool ResolveLast, UnitCollection uc, Unit *superunit)

void	AddVelocity (float difficulty)

virtual Vector	ResolveForces (const Transformation &, const Matrix &)

void	SetOrientation (QVector q, QVector r)

void	SetOrientation (Quaternion Q)

void	SetOrientation (QVector p, QVector q, QVector r)

void	GetOrientation (Vector &p, Vector &q, Vector &r) const

Vector	GetNetAcceleration ()

Vector	GetAcceleration () const

float	GetMaxAccelerationInDirectionOf (const Vector &ref, bool afterburn) const

Vector	UpCoordinateLevel (const Vector &v) const

Vector	DownCoordinateLevel (const Vector &v) const

Vector	ToLocalCoordinates (const Vector &v) const

Vector	ToWorldCoordinates (const Vector &v) const

const Vector &	GetAngularVelocity () const

const Vector &	GetVelocity () const

Vector	GetWarpVelocity () const

void	SetVelocity (const Vector &)

void	SetAngularVelocity (const Vector &)

float	GetMoment () const

float	GetMass () const

float	GetElasticity ()

const Limits &	Limits () const

void	SetResolveForces (bool)

void	setAverageGunSpeed ()

int	LockMissile () const

void	LockTarget (bool myboo)

bool	TargetLocked () const

float	TrackingGuns (bool &missileLock)

void	ToggleWeapon (bool Missile, bool forward=true)

void	SelectAllWeapon (bool Missile)

void	getAverageGunSpeed (float &speed, float &grange, float &mrange) const

QVector	PositionITTS (const QVector &firingposit, Vector firingvelocity, float gunspeed, bool smooth_itts) const

float	FShieldData () const

float	RShieldData () const

float	LShieldData () const

float	BShieldData () const

void	ArmorData (float armor[8]) const

float	GetHull () const

float	GetHullPercent () const

void	Fire (unsigned int bitmask, bool beams_target_owner=false)

void	UnFire ()

void	leach (float XshieldPercent, float YrechargePercent, float ZenergyPercent)

bool	InRange (Unit *target, bool cone=true, bool cap=true) const

bool	InRange (Unit *target, double &mm, bool cone, bool cap, bool lock) const

Unit *	Target ()

Unit *	VelocityReference ()

Unit *	Threat ()

void	VelocityReference (Unit *targ)

void	TargetTurret (Unit *targ)

void	Threaten (Unit *targ, float danger)

void	ResetThreatLevel ()

float	cosAngleTo (Unit *target, float &distance, float speed=0.001, float range=0.001, bool turnmargin=true) const

float	cosAngleFromMountTo (Unit *target, float &distance) const

float	computeLockingPercent ()

void	Select ()

void	Deselect ()

void	Target (Unit *targ)

void	setTargetFg (std::string primary, std::string secondary=std::string(), std::string tertiary=std::string())

void	ReTargetFg (int which_target=0)

bool	CanAddCargo (const Cargo &carg) const

void	AddCargo (const Cargo &carg, bool sort=true)

int	RemoveCargo (unsigned int i, int quantity, bool eraseZero=true)

float	PriceCargo (const std::string &s)

Cargo &	GetCargo (unsigned int i)

const Cargo &	GetCargo (unsigned int i) const

void	GetSortedCargoCat (const std::string &category, size_t &catbegin, size_t &catend)

Cargo *	GetCargo (const std::string &s, unsigned int &i)

const Cargo *	GetCargo (const std::string &s, unsigned int &i) const

unsigned int	numCargo () const

std::string	GetManifest (unsigned int i, Unit *scanningUnit, const Vector &original_velocity) const

bool	SellCargo (unsigned int i, int quantity, float &creds, Cargo &carg, Unit *buyer)

bool	SellCargo (const std::string &s, int quantity, float &creds, Cargo &carg, Unit *buyer)

bool	BuyCargo (const Cargo &carg, float &creds)

bool	BuyCargo (unsigned int i, unsigned int quantity, Unit *buyer, float &creds)

bool	BuyCargo (const std::string &cargo, unsigned int quantity, Unit *buyer, float &creds)

void	EjectCargo (unsigned int index)

float	getEmptyCargoVolume (void) const

float	getCargoVolume (void) const

float	getEmptyUpgradeVolume (void) const

float	getUpgradeVolume (void) const

float	getHiddenCargoVolume (void) const

class csOPCODECollider *	getCollideTree (const Vector &scale=Vector(1, 1, 1), const std::vector< struct mesh_polygon > *=NULL)

Order *	getAIState () const

void	PrimeOrders ()

void	PrimeOrdersLaunched ()

void	PrimeOrders (Order *newAI)

void	SetAI (Order *newAI)

void	EnqueueAI (Order *newAI)

void	EnqueueAIFirst (Order *newAI)

void	LoadAIScript (const std::string &aiscript)

bool	LoadLastPythonAIScript ()

bool	EnqueueLastPythonAIScript ()

double	getMinDis (const QVector &pnt)

void	SetTurretAI ()

void	DisableTurretAI ()

std::string	getFullAIDescription ()

void	eraseOrderType (unsigned int type)

void	ExecuteAI ()

void	SetCollisionParent (Unit *name)

void	SetOwner (Unit *target)

void	SetRecursiveOwner (Unit *target)

Unit *	rayCollide (const QVector &st, const QVector &end, Vector &normal, float &distance)

void	calculate_extent (bool update_collide_queue)

bool	Inside (const QVector &position, const float radius, Vector &normal, float &dist)

void	UpdateCollideQueue (StarSystem *ss, CollideMap::iterator hint[NUM_COLLIDE_MAPS])

bool	querySphere (const QVector &pnt, float err) const

float	querySphere (const QVector &start, const QVector &end, float my_unit_radius=0) const

float	querySphereNoRecurse (const QVector &start, const QVector &end, float my_unit_radius=0) const

float	querySphereClickList (const QVector &st, const QVector &dir, float err) const

bool	queryFrustum (double frustum[6][4]) const

virtual bool	querySphereClickList (int, int, float err, Camera *activeCam)

bool	InsideCollideTree (Unit *smaller, QVector &bigpos, Vector &bigNormal, QVector &smallpos, Vector &smallNormal, bool bigasteroid=false, bool smallasteroid=false)

bool	jumpReactToCollision (Unit *smaller)

bool	Collide (Unit *target)

void	CollideAll ()

int	CanDockWithMe (Unit *dockingunit, bool forcedock=false)

int	ForceDock (Unit *utdw, unsigned int whichdockport)

void	PerformDockingOperations ()

void	FreeDockingPort (unsigned int whichport)

const std::vector< struct DockingPorts > &	DockingPortLocations () const

char	DockedOrDocking () const

bool	IsCleared (const Unit *dockignunit) const

bool	isDocked (const Unit *dockingUnit) const

bool	UnDock (Unit *unitToDockWith)

bool	RequestClearance (Unit *dockingunit)

bool	EndRequestClearance (Unit *dockingunit)

bool	hasPendingClearanceRequests () const

int	Dock (Unit *unitToDockWith)

void	RestoreGodliness ()

void	SetFg (Flightgroup *fg, int fg_snumber)

void	SetFaction (int faction)

Flightgroup *	getFlightgroup () const

int	getFgSubnumber () const

const std::string	getFgID ()

std::vector< class CargoColor > &	FilterDowngradeList (std::vector< class CargoColor > &mylist, bool downgrade=true)

std::vector< class CargoColor > &	FilterUpgradeList (std::vector< class CargoColor > &mylist)

bool	IsBase () const

bool	isTractorable (enum tractorHow how=tractorBoth) const

void	setTractorability (enum tractorHow how)

enum tractorHow	getTractorability () const

void	setFullname (std::string name)

const string &	getFullname () const

const string &	getFilename () const

void	Ref ()

void	UnRef ()

UnitImages< void > &	GetImageInformation ()

bool	isStarShip () const

bool	isPlanet () const

bool	isJumppoint () const

bool	isEnemy (const Unit *other) const

bool	isFriend (const Unit *other) const

bool	isNeutral (const Unit *other) const

float	getRelation (const Unit *other) const

void	TurretFAW ()

Protected Member Functions
	Missile (std::vector< Mesh * >m, bool b, int i)

virtual float	ExplosionRadius ()

	Missile (const char *filename, int faction, const string &modifications, const float damage, float phasedamage, float time, float radialeffect, float radmult, float detonation_radius)
	constructor only to be called by UnitFactory More...

void	InitMissile (float ptime, const float pdamage, float pphasedamage, float pradial_effect, float pradial_multiplier, float pdetonation_radius, bool pdischarged, signed char pretarget)

	Missile ()
	default constructor forbidden More...

Protected Member Functions inherited from Unit
	Unit (const Unit &)

Unit &	operator= (const Unit &)

void	ActivateGuns (const weapon_info *, bool Missile)
	cycles through the loop twice turning on all matching to ms weapons of size or after size More...

float	MaxShieldVal () const

void	RegenShields ()

virtual float	DealDamageToShield (const Vector &pnt, float &Damage)

bool	ShieldUp (const Vector &) const

void	SortCargo ()

Protected Attributes
float	time

float	damage

float	phasedamage

float	radial_effect

float	radial_multiplier

float	detonation_radius

bool	discharged

bool	had_target

signed char	retarget

Protected Attributes inherited from Unit
StringPool::Reference	csvRow

bool	networked

ObjSerial	serial

Vector	net_accel

unsigned char	attack_preference

unsigned char	unit_role

Nebula *	nebula

float	shieldtight

float	fuel

float	afterburnenergy

int	afterburntype

float	Momentofinertia

Vector	SavedAccel

unsigned char	invisible

float	maxhull

float	recharge

float	maxenergy

float	maxwarpenergy

float	warpenergy

StringPool::Reference	target_fgid [3]

Flightgroup *	flightgroup

int	flightgroup_subnumber

std::string	fullname

Friends
class	UnitFactory

Additional Inherited Members
Public Types inherited from Unit
enum	DAMAGES { NO_DAMAGE =0x00, SHIELD_DAMAGED =0x01, COMPUTER_DAMAGED =0x02, MOUNT_DAMAGED =0x04, CARGOFUEL_DAMAGED =0x08, JUMP_DAMAGED =0x10, CLOAK_DAMAGED =0x20, LIMITS_DAMAGED =0x40, ARMOR_DAMAGED =0x80 }

enum	schedulepriorityenum { scheduleDefault, scheduleAField, scheduleRoid }

enum	COLLIDELOCATIONTYPES { UNIT_ONLY =0, UNIT_BOLT =1, NUM_COLLIDE_MAPS =2 }

enum	DOCKENUM { NOT_DOCKED =0x0, DOCKED_INSIDE =0x1, DOCKED =0x2, DOCKING_UNITS =0x4 }

enum	tractorHow { tractorImmune =0, tractorPush =1, tractorIn =2, tractorBoth =3 }

Static Public Member Functions inherited from Unit
static void	ProcessDeleteQueue ()

static void	beginElement (void userData, const XML_Char name, const XML_Char **atts)

static void	endElement (void userData, const XML_Char name)

static Unit *	makeMasterPartList ()

Public Attributes inherited from Unit
bool	killed

bool	zapped

int	ucref

UnitSounds *	sound

StringPool::Reference	name

StringPool::Reference	filename

ClientState	old_state

unsigned short	damages

UnitCollection	SubUnits

std::vector< Mount >	mounts

float	gunspeed

float	gunrange

float	missilerange

bool	inertialmode

char	turretstatus

bool	autopilotactive

class Unit::graphic_options	graphicOptions

std::vector< Mesh * >	meshdata

StarSystem *	activeStarSystem

class Unit::Computer	computer

struct Unit::UnitJump	jump

Pilot *	pilot

bool	selected

XML *	xml

void *	owner

unsigned int	sim_atom_multiplier

unsigned int	predicted_priority

Transformation	prev_physical_state

Transformation	curr_physical_state

unsigned int	cur_sim_queue_slot

unsigned int	last_processed_sqs

bool	do_subunit_scheduling

enum Unit::schedulepriorityenum	schedule_priority

Matrix	cumulative_transformation_matrix

Transformation	cumulative_transformation

Vector	cumulative_velocity

Vector	NetForce

Vector	NetLocalForce

Vector	NetTorque

Vector	NetLocalTorque

Vector	AngularVelocity

Vector	Velocity

UnitImages< void > *	pImage

float	specInterdiction

float	Mass

float	HeatSink

class Unit::Limits	limits

int	cloaking

int	cloakmin

float	radial_size

Vector	corner_min

Vector	corner_max

bool	resolveforces

Armor	armor

Shield	shield

float	hull

float	energy

Order *	aistate

CollideMap::iterator	location [2]

struct collideTrees *	colTrees

unsigned char	docked

int	faction

MeshAnimation *	pMeshAnimation

Protected Types inherited from Unit
enum	INVIS { DEFAULTVIS =0x0, INVISGLOW =0x1, INVISUNIT =0x2, INVISCAMERA =0x4 }

Static Protected Member Functions inherited from Unit
static std::string	massSerializer (const struct XMLType &input, void *mythis)

static std::string	cargoSerializer (const struct XMLType &input, void *mythis)

static std::string	mountSerializer (const struct XMLType &input, void *mythis)

static std::string	shieldSerializer (const struct XMLType &input, void *mythis)

static std::string	subunitSerializer (const struct XMLType &input, void *mythis)

Detailed Description

Definition at line 32 of file missile_generic.h.

Constructor & Destructor Documentation

Missile::Missile	(	std::vector< Mesh * >	m,
		bool	b,
		int	i
	)

inlineprotected

Definition at line 35 of file missile_generic.h.

35 : Missile( std::vector< Mesh* >m, bool b, int i ) : Unit( m, b, i ) {}

Missile::Missile	(	const char *	filename,
		int	faction,
		const string &	modifications,
		const float	damage,
		float	phasedamage,
		float	time,
		float	radialeffect,
		float	radmult,
		float	detonation_radius
	)

inlineprotected

constructor only to be called by UnitFactory

Definition at line 55 of file missile_generic.h.

References had_target, and Unit::maxhull.

                                        :
         Unit( filename, false, faction, modifications )
         , time( time )
         , damage( damage )
         , phasedamage( phasedamage )
         , radial_effect( radialeffect )
         , radial_multiplier( radmult )
         , detonation_radius( detonation_radius )
         , discharged( false )
         , retarget( -1 )
     {
         maxhull   *= 10;
         had_target = false;
     }

Missile::Missile ( )

inlineprotected

default constructor forbidden

Definition at line 118 of file missile_generic.h.

118 {}

Member Function Documentation

void Missile::Discharge ( )

Definition at line 71 of file missile_generic.cpp.

References _Universe, Universe::activeStarSystem(), StarSystem::AddMissileToQueue(), damage, discharged, Unit::owner, phasedamage, Unit::Position(), radial_effect, and radial_multiplier.

Referenced by GameMissile::Kill(), Kill(), GameMissile::reactToCollision(), reactToCollision(), GameMissile::UpdatePhysics2(), and UpdatePhysics2().

 {
     if ( (damage != 0 || phasedamage != 0) && !discharged )
         _Universe->activeStarSystem()->AddMissileToQueue( new MissileEffect( Position().Cast(), damage, phasedamage,
                                                                              radial_effect, radial_multiplier, owner ) );
     discharged = true;
 }

float Missile::ExplosionRadius ( )

protectedvirtual

Reimplemented from Unit.

Definition at line 59 of file missile_generic.cpp.

References VegaConfig::getVariable(), XMLSupport::parse_float(), radial_effect, and vs_config.

 {
     static float missile_multiplier =
         XMLSupport::parse_float( vs_config->getVariable( "graphics", "missile_explosion_radius_mult", "1" ) );
 
     return radial_effect*(missile_multiplier);
 }

void Missile::InitMissile	(	float	ptime,
		const float	pdamage,
		float	pphasedamage,
		float	pradial_effect,
		float	pradial_multiplier,
		float	pdetonation_radius,
		bool	pdischarged,
		signed char	pretarget
	)

inlineprotected

Definition at line 78 of file missile_generic.h.

References damage, detonation_radius, discharged, had_target, phasedamage, radial_effect, radial_multiplier, retarget, and time.

Referenced by GameMissile::GameMissile().

     {
         time   = ptime;
         damage = pdamage;
         phasedamage = pphasedamage;
         radial_effect     = pradial_effect;
         radial_multiplier = pradial_multiplier;
         detonation_radius = pdetonation_radius;
         discharged = pdischarged;
         retarget   = pretarget;
         had_target = false;
     }

virtual enum clsptr Missile::isUnit ( ) const

inlinevirtual

Reimplemented from Unit.

Definition at line 48 of file missile_generic.h.

References MISSILEPTR.

     {
         return MISSILEPTR;
     }

void Missile::Kill ( bool eraseFromSave = true)

virtual

Reimplemented in GameMissile.

Definition at line 78 of file missile_generic.cpp.

References Discharge(), and Unit::Kill().

 {
     Discharge();
     Unit::Kill( erase );
 }

void Missile::reactToCollision	(	Unit *	smaller,
		const QVector &	biglocation,
		const Vector &	bignormal,
		const QVector &	smalllocation,
		const Vector &	smallnormal,
		float	dist
	)

virtual

Reimplemented from Unit.

Reimplemented in GameMissile.

Definition at line 83 of file missile_generic.cpp.

References Unit::DealDamageToHull(), Discharge(), VegaConfig::getVariable(), Unit::hull, Unit::isUnit(), Unit::killed, MISSILEPTR, XMLSupport::parse_bool(), Unit::reactToCollision(), Unit::Velocity, and vs_config.

 {
     static bool doesmissilebounce = XMLSupport::parse_bool( vs_config->getVariable( "physics", "missile_bounce", "false" ) );
     if (doesmissilebounce)
         Unit::reactToCollision( smaller, biglocation, bignormal, smalllocation, smallnormal, dist );
     if (smaller->isUnit() != MISSILEPTR) {
         //2 missiles in a row can't hit each other
         this->Velocity = smaller->Velocity;
         Velocity = smaller->Velocity;
         Discharge();
         if (!killed)
             DealDamageToHull( smalllocation.Cast(), hull+1 );              //should kill, applying addmissile effect
     }
 }

void Missile::UpdatePhysics2	(	const Transformation &	trans,
		const Transformation &	old_physical_state,
		const Vector &	accel,
		float	difficulty,
		const Matrix &	transmat,
		const Vector &	CumulativeVelocity,
		bool	ResolveLast,
		UnitCollection *	uc = `NULL`
	)

virtual

Reimplemented from Unit.

Reimplemented in GameUnit< Missile >, and GameMissile.

Definition at line 141 of file missile_generic.cpp.

References Unit::attackPreference(), Unit::DealDamageToHull(), detonation_radius, Discharge(), Unit::getAverageGunSpeed(), UnitUtil::getECM(), ROLES::getRole(), Unit::getSubUnits(), VegaConfig::getVariable(), Unit::GetVelocity(), Unit::graphicOptions, had_target, Unit::hull, i, Magnitude(), Unit::graphic_options::missilelock, XMLSupport::parse_float(), XMLSupport::parse_int(), Unit::Position(), Unit::querySphere(), retarget, Unit::rSize(), SIMULATION_ATOM, speed, Unit::Target(), Unit::TargetTurret(), time, Unit::UpdatePhysics2(), Vector, Unit::Velocity, and vs_config.

 {
     Unit *targ;
     if ( ( targ = ( Unit::Target() ) ) ) {
         had_target = true;
         if (targ->hull < 0) {
             targ = NULL;
         } else {
             static size_t max_ecm = (size_t)XMLSupport::parse_int( vs_config->getVariable( "physics", "max_ecm", "4" ) );
             size_t missile_hash = ( (size_t) this ) / 16383;
             if ( (int)(missile_hash%max_ecm) < UnitUtil::getECM(targ)) {
                 Target( NULL );                 //go wild
             } else if (hull > 0) {
                 static unsigned int pointdef = ROLES::getRole( "POINTDEF" );
                 targ->graphicOptions.missilelock = true;
                 un_iter i = targ->getSubUnits();
 
                 Unit   *su;
                 for (; (su = *i) != NULL; ++i)
                     if (su->attackPreference() == pointdef) {
                         if (su->Target() == NULL) {
                             float speed, range, mrange;
                             su->getAverageGunSpeed( speed, range, mrange );
                             if ( ( Position()-su->Position() ).MagnitudeSquared() < range*range ) {
                                 su->Target( this );
                                 su->TargetTurret( this );
                             }
                         }
                     }
             }
         }
     }
     if (retarget == -1) {
         if (targ)
             retarget = 1;
         else
             retarget = 0;
     }
     if (retarget && targ == NULL)
         Target( NULL );          //BROKEN
     if ( had_target && !( Unit::Target() ) ) {
         static float max_lost_target_live_time =
             XMLSupport::parse_float( vs_config->getVariable( "physics", "max_lost_target_live_time", "30" ) );
         if (time > max_lost_target_live_time)
             time = max_lost_target_live_time;
     }
     Unit::UpdatePhysics2( trans, old_physical_state, accel, difficulty, transmat, CumulativeVelocity, ResolveLast, uc );
     this->time -= SIMULATION_ATOM;
     if (NULL != targ) {
         float checker = targ->querySphere( Position()-( SIMULATION_ATOM*GetVelocity() ), Position(), rSize() );
         if ( (checker
               && detonation_radius >= 0)
             || ( ( Position()-targ->Position() ).Magnitude()-targ->rSize()-rSize() < detonation_radius ) ) {
             //spiritplumber assumes that the missile is hitting a much larger object than itself
             static float percent_missile_match_target_velocity =
                 XMLSupport::parse_float( vs_config->getVariable( "physics", "percent_missile_match_target_velocity", ".5" ) );
 
             this->Velocity += percent_missile_match_target_velocity*(targ->Velocity-this->Velocity);
             Discharge();
             time = -1;
             //Vector norm;
             //float dist;
             /*** WARNING COLLISION STUFF... TO FIX FOR SERVER SIDE SOMEDAY ***
              *    if ((targ)->queryBoundingBox (Position(),detonation_radius+rSize())) {
              *    Discharge();
              *    time=-1;
              *    }
              */
         }
     }
     if (time < 0)
         DealDamageToHull( Vector( .1, .1, .1 ), hull+1 );
 }