#include <unit_generic.h>

Classes
union	REF

Public Types
enum	MOUNTSTATUS { REQUESTED, ACCEPTED, PROCESSED, UNFIRED, FIRED }

enum	STATUS { ACTIVE, INACTIVE, DESTROYED, UNCHOSEN }

Public Member Functions
float	ComputeAnimatedFrame (Mesh *gun)

void	ReplaceMounts (Unit unit, const Mount other)

double	Percentage (const Mount *newammo) const

	Mount ()

	Mount (const std::string &name, int ammo, int volume, float xyscale, float zscale, float functionality, float maxfunctionality, bool banked)

void	Activate (bool Missile)

void	DeActive (bool Missile)
	Sets this gun to inactive, unless unchosen or destroyed. More...

void	SetMountPosition (const Vector &)

void	SetMountOrientation (const Quaternion &)

const Vector &	GetMountLocation () const

const Quaternion &	GetMountOrientation () const

void	UnFire ()

void	PhysicsAlignedUnfire ()

bool	PhysicsAlignedFire (Unit caller, const Transformation &Cumulative, const Matrix &mat, const Vector &Velocity, void owner, Unit *target, signed char autotrack, float trackingcone, CollideMap::iterator hint[])

bool	NextMountCloser (Mount nextmount, Unit )

bool	Fire (Unit firer, void owner, bool Missile=false, bool collide_only_with_target=false)

bool	IsEmpty () const

Public Attributes
ObjSerial	serial

float	xyscale

float	zscale

union Mount::REF	ref

unsigned int	size

int	ammo

int	volume

enum Mount::MOUNTSTATUS	processed

enum Mount::STATUS	status

bool	bank

const weapon_info *	type

float	functionality

float	maxfunctionality

int	sound

float	time_to_lock

Protected Member Functions
void	ReplaceSound ()

Protected Attributes
Vector	pos

Quaternion	orient

double	last_sound_refire_time

Detailed Description

Definition at line 108 of file unit_generic.h.

Member Enumeration Documentation

enum Mount::MOUNTSTATUS

Enumerator
REQUESTED
ACCEPTED
PROCESSED
UNFIRED
FIRED

Definition at line 141 of file unit_generic.h.

141 {REQUESTED, ACCEPTED, PROCESSED, UNFIRED, FIRED}

enum Mount::STATUS

Enumerator
ACTIVE
INACTIVE
DESTROYED
UNCHOSEN

Definition at line 144 of file unit_generic.h.

144 {ACTIVE, INACTIVE, DESTROYED, UNCHOSEN}

Constructor & Destructor Documentation

Mount::Mount ( )

Definition at line 23 of file mount.cpp.

References ammo, weapon_info::BEAM, functionality, VegaConfig::getVariable(), last_sound_refire_time, maxfunctionality, weapon_info::NOWEAP, XMLSupport::parse_float(), PROCESSED, processed, serial, size, sound, status, type, UNCHOSEN, vs_config, xyscale, and zscale.

 {
     static weapon_info wi( weapon_info::BEAM );
     functionality    = 1;
     maxfunctionality = 1;
     type = &wi;
     size = weapon_info::NOWEAP;
     functionality    = maxfunctionality = 1.0f;
     ammo = -1;
     status    = UNCHOSEN;
     processed = Mount::PROCESSED;
     sound     = -1;
     last_sound_refire_time = 0.0;
     static float xyscalestat = XMLSupport::parse_float( vs_config->getVariable( "graphics", "weapon_xyscale", "1" ) );
 
     static float zscalestat  = XMLSupport::parse_float( vs_config->getVariable( "graphics", "weapon_zscale", "1" ) );
     xyscale = xyscalestat;
     zscale  = zscalestat;
     serial  = 0;
 }

Mount::Mount	(	const std::string &	name,
		int	ammo,
		int	volume,
		float	xyscale,
		float	zscale,
		float	functionality,
		float	maxfunctionality,
		bool	banked
	)

Member Function Documentation

void Mount::Activate ( bool Missile)

Definition at line 5373 of file unit_generic.cpp.

References isMissile().

 {
     if ( ( isMissile( type ) ) == Missile )
         if (status == INACTIVE)
             status = ACTIVE;
 }

float Mount::ComputeAnimatedFrame ( Mesh * gun)

Definition at line 50 of file mount.cpp.

References weapon_info::BEAM, Mesh::getFramesPerSecond(), getNewTime(), Mount::REF::gun, interpolation_blend_factor, Beam::Ready(), ref, weapon_info::Refire(), Mount::REF::refire, Beam::refireTime(), SIMULATION_ATOM, weapon_info::type, and type.

 {
     if (type->type == weapon_info::BEAM) {
         if (ref.gun) {
             if ( ref.gun->Ready() )
                 return getNewTime()+type->Refire()-ref.gun->refireTime()-interpolation_blend_factor*SIMULATION_ATOM;
             else
                 return getNewTime()*gun->getFramesPerSecond();
         } else {
             return 0;
         }
     } else {
         if ( ref.refire < type->Refire() )
             return getNewTime()*gun->getFramesPerSecond();
         else
             return getNewTime()+type->Refire()-ref.refire-interpolation_blend_factor*SIMULATION_ATOM;
     }
 }

void Mount::DeActive ( bool Missile)

Sets this gun to inactive, unless unchosen or destroyed.

Definition at line 5381 of file unit_generic.cpp.

References isMissile().

 {
     if ( ( isMissile( type ) ) == Missile )
         if (status == ACTIVE)
             status = INACTIVE;
 }

bool Mount::Fire	(	Unit *	firer,
		void *	owner,
		bool	Missile = `false`,
		bool	collide_only_with_target = `false`
	)

Definition at line 448 of file mount.cpp.

References _Universe, Universe::AccessCockpit(), ACTIVE, ammo, weapon_info::BEAM, FIRED, forcefeedback, Cockpit::GetParent(), Mount::REF::gun, isMissile(), Beam::ListenToOwner(), orient, ForceFeedback::playLaser(), pos, processed, Beam::Ready(), ref, weapon_info::Refire(), Mount::REF::refire, sound, status, weapon_info::type, type, and UNFIRED.

Referenced by Unit::Fire().

 {
     if (ammo == 0)
         processed = UNFIRED;
     if (processed == FIRED || status != ACTIVE || ( Missile != ( isMissile( type ) ) ) || ammo == 0)
         return false;
     if (type->type == weapon_info::BEAM) {
         bool fireit = ref.gun == NULL;
         if (!fireit)
             fireit = ref.gun->Ready();
         else
             ref.gun = new Beam( Transformation( orient, pos.Cast() ), *type, owner, firer, sound );
         if (fireit) {
             ref.gun->ListenToOwner( listen_to_owner );
             processed = FIRED;
         }
         return true;
     } else if ( ref.refire >= type->Refire() ) {
         processed = FIRED;
         if ( owner == _Universe->AccessCockpit()->GetParent() )
             forcefeedback->playLaser();
         ;
 
         return true;
     }
     return false;
 }

const Vector& Mount::GetMountLocation ( ) const

inline

Definition at line 171 of file unit_generic.h.

References pos.

Referenced by UnitWrapper::GetMountInfo(), and ReplaceMounts().

     {
         return pos;
     }

const Quaternion& Mount::GetMountOrientation ( ) const

inline

Definition at line 175 of file unit_generic.h.

References orient.

Referenced by UnitWrapper::GetMountInfo(), and ReplaceMounts().

     {
         return orient;
     }

bool Mount::IsEmpty ( ) const

inline

Definition at line 199 of file unit_generic.h.

References ACTIVE, INACTIVE, and status.

Referenced by UnitWrapper::GetMountInfo().

     {
         return !(status == ACTIVE || status == INACTIVE);
     }

bool Mount::NextMountCloser	(	Mount *	nextmount,
		Unit *	firer
	)

Definition at line 431 of file mount.cpp.

References Matrix::getR(), Unit::LocalCoordinates(), orient, pos, Unit::Target(), Quaternion::to_matrix(), and Vector.

Referenced by Unit::Fire().

 {
     Unit *target;
     if ( nextmount && ( target = firer->Target() ) ) {
         Matrix mat;
         nextmount->orient.to_matrix( mat );
         Vector nextR = mat.getR();
         this->orient.to_matrix( mat );
         Vector diff  = firer->LocalCoordinates( target );
         Vector nextmountnorm = diff-nextmount->pos;
         nextmountnorm.Normalize();
         Vector thismountnorm = diff-this->pos;
         thismountnorm.Normalize();
         return nextR.Dot( nextmountnorm ) > mat.getR().Dot( thismountnorm );
     }
     return false;
 }

double Mount::Percentage ( const Mount * newammo) const

Definition at line 147 of file mount.cpp.

References ammo, weapon_info::Damage, DESTROYED, weapon_info::PhaseDamage, weapon_info::Range, status, type, UNCHOSEN, and weapon_info::weapon_name.

 {
     float percentage = 1./1024;
     int   thingstocompare = 0;
     if (status == UNCHOSEN || status == DESTROYED)
         return percentage;
     if (newammo->ammo == -1) {
         if (ammo != -1) {
             thingstocompare++;
         } else {
             if (newammo->type->Range == type->Range && newammo->type->Damage == type->Damage && newammo->type->PhaseDamage
                 == type->PhaseDamage)
                 return 1;
             if (newammo->type->weapon_name == type->weapon_name)
                 return 1;
         }
     } else if (newammo->ammo > 0) {
         percentage += .25;
         thingstocompare++;
         if (ammo > 0) {
             if (newammo->type->Range == type->Range && newammo->type->Damage == type->Damage && newammo->type->PhaseDamage
                 == type->PhaseDamage)
                 return 1;
             if (newammo->type->weapon_name == type->weapon_name)
                 return 1;
         }
     }
     if (newammo->type->Range) {
         if (type->Range > newammo->type->Range) percentage += .25;
         thingstocompare++;
     }
     if (newammo->type->Damage+100*newammo->type->PhaseDamage) {
         if (type->Damage+100*type->PhaseDamage > newammo->type->Damage+100*newammo->type->PhaseDamage) percentage += .75;
         thingstocompare++;
     }
     if (thingstocompare)
         return percentage/thingstocompare;
     else
         return 1./1024;
 }

bool Mount::PhysicsAlignedFire	(	Unit *	caller,
		const Transformation &	Cumulative,
		const Matrix &	mat,
		const Vector &	Velocity,
		void *	owner,
		Unit *	target,
		signed char	autotrack,
		float	trackingcone,
		CollideMap::iterator	hint[]
	)

Definition at line 190 of file mount.cpp.

References _Universe, Universe::activeStarSystem(), StarSystem::AddUnit(), AdjustMatrix(), VSFileSystem::AiFile, ammo, AUDAdjustSound(), AUDCreateSound(), AUDDeleteSound(), AUDIsPlaying(), AUDListenerLocation(), AUDPlay(), AUDSoundGain(), AUDStopPlaying(), weapon_info::AUTOTRACKING, weapon_info::BALL, weapon_info::BEAM, weapon_info::BOLT, Transformation::Compose(), CopyMatrix(), CP_RIGHT, UnitFactory::createMissile(), UnitFactory::createUnit(), Unit::cumulative_transformation, Unit::cumulative_transformation_matrix, Unit::curr_physical_state, weapon_info::Damage, Flightgroup::directive, Unit::energy, weapon_info::EnergyRate, Unit::EnqueueAI(), Unit::faction, weapon_info::file, FIRED, Unit::GetComputerData(), FactionUtil::GetFactionName(), Unit::getFlightgroup(), GetMadAt(), Unit::getRelation(), VegaConfig::getVariable(), Unit::GetVelocity(), Mount::REF::gun, i, Beam::Init(), is_null(), isMissile(), Universe::isPlayerStarshipVoid(), Unit::isSubUnit(), last_sound_refire_time, Bolt::location, Unit::location, weapon_info::LockTime, VSFileSystem::LookForFile(), Unit::Computer::max_combat_ab_speed, Unit::Computer::max_combat_speed, mission, Flightgroup::name, Network, Flightgroup::newFlightgroup(), Flightgroup::nr_ships, Flightgroup::nr_ships_left, Unit::NUM_COLLIDE_MAPS, weapon_info::offset, VSFileSystem::Ok, orient, Unit::owner, Matrix::p, XMLSupport::parse_bool(), XMLSupport::parse_float(), weapon_info::PhaseDamage, pos, Unit::prev_physical_state, PROCESSED, processed, weapon_info::PROJECTILE, weapon_info::PulseSpeed, QVector, Matrix::r, weapon_info::RadialSpeed, weapon_info::Radius, weapon_info::Range, realTime(), ref, weapon_info::Refire(), Mount::REF::refire, serial, SERVER, Unit::SetOwner(), Unit::SetSerial(), Unit::SetTurretAI(), UnitContainer::SetUnit(), Unit::SetVelocity(), size, sound, weapon_info::Speed, Flightgroup::target, Unit::Target(), Unit::TargetTurret(), time_to_lock, Transform(), Unit::TurretFAW(), weapon_info::type, type, Unit::UNIT_BOLT, weapon_info::UNKNOWN, Unit::UpdateCollideQueue(), Vector, Unit::Velocity, Unit::Computer::velocity_ref, vs_config, and VSFileSystem::vs_dprintf().

 {
     using namespace VSFileSystem;
     if (time_to_lock > 0)
         target = NULL;
     static bool lock_disrupted_by_false_fire =
         XMLSupport::parse_bool( vs_config->getVariable( "physics", "out_of_arc_fire_disrupts_lock", "false" ) );
     if (lock_disrupted_by_false_fire)
         time_to_lock = type->LockTime;
     if (processed == FIRED) {
         if ( type->type == weapon_info::BEAM || isMissile( type ) )
             //Missiles and beams set to processed.
             processed = PROCESSED;
         else if (ref.refire < type->Refire() || type->EnergyRate > caller->energy)
             //Wait until refire has expired and reactor has produced enough energy for the next bolt.
             return true;              //Not ready to refire yet.  But don't stop firing.
 
         Unit  *temp;
         Transformation tmp( orient, pos.Cast() );
         tmp.Compose( Cumulative, m );
         Matrix mat;
         tmp.to_matrix( mat );
         mat.p = Transform( mat, ( type->offset+Vector( 0, 0, zscale ) ).Cast() );
         static bool firemissingautotrackers =
             XMLSupport::parse_bool( vs_config->getVariable( "physics", "fire_missing_autotrackers", "true" ) );
         if (autotrack && NULL != target) {
             if ( !AdjustMatrix( mat, velocity, target, type->Speed, autotrack >= 2, trackingcone ) )
                 if (!firemissingautotrackers)
                     return false;
         } else if (this->size&weapon_info::AUTOTRACKING) {
             if (!firemissingautotrackers)
                 return false;
         }
         if (type->type != weapon_info::BEAM) {
             ref.refire = 0;
             if (ammo > 0)
                 ammo--;
         } else {
             static bool reduce_beam_ammo = XMLSupport::parse_bool( vs_config->getVariable( "physics", "reduce_beam_ammo", "0" ) );
             if (ammo > 0 && reduce_beam_ammo)
                 ammo--;
         }
         time_to_lock = type->LockTime;
         switch (type->type)
         {
         case weapon_info::UNKNOWN:
             break;
         case weapon_info::BEAM:
             if (ref.gun)
                 ref.gun->Init( Transformation( orient, pos.Cast() ), *type, owner, caller );
             break;
         case weapon_info::BOLT:
         case weapon_info::BALL:
             caller->energy -= type->EnergyRate;
             hint[Unit::UNIT_BOLT] = Bolt( type, mat, velocity, owner, hint[Unit::UNIT_BOLT] ).location;             //FIXME turrets won't work! Velocity
 
             break;
         case weapon_info::PROJECTILE:
             if (Network == NULL || SERVER) {
                 //Server will create a networked unit, and send it over to the client.
                 static bool match_speed_with_target =
                     XMLSupport::parse_float( vs_config->getVariable( "physics", "match_speed_with_target", "true" ) );
                 string skript   = /*string("ai/script/")+*/ type->file+string( ".xai" );
                 VSError     err = LookForFile( skript, AiFile );
                 if (err <= Ok) {
                     temp = UnitFactory::createMissile(
                         type->file.c_str(), caller->faction, "", type->Damage, type->PhaseDamage, type->Range/type->Speed,
                         type->Radius, type->RadialSpeed, type->PulseSpeed /*detonation_radius*/, this->serial );
                     if (!match_speed_with_target) {
                         temp->GetComputerData().max_combat_speed    = type->Speed+velocity.Magnitude();
                         temp->GetComputerData().max_combat_ab_speed = type->Speed+velocity.Magnitude();
                     }
                 } else {
                     Flightgroup *testfg = caller->getFlightgroup();
                     if (testfg == NULL) {
                         static Flightgroup bas;
                         bas.name = "Base";
                         testfg   = &bas;
                     }
                     if (testfg->name == "Base") {
                         int fgsnumber   = 0;
                         Flightgroup *fg = Flightgroup::newFlightgroup( "Base_Patrol",
                                                                        type->file,
                                                                        FactionUtil::GetFactionName( caller->faction ),
                                                                        "deafult",
                                                                        1,
                                                                        1,
                                                                        "",
                                                                        "",
                                                                        mission );
                         if (fg != NULL) {
                             fg->target.SetUnit( caller->Target() );
                             fg->directive     = "a";
                             fg->name = "Base_Patrol";                               //this fixes base-spawned fighters becoming navpoints, which happens sometimes
 
                             fgsnumber         = fg->nr_ships;
                             fg->nr_ships      = 1;
                             fg->nr_ships_left = 1;
                         }
                         temp = UnitFactory::createUnit(
                             type->file.c_str(), false, caller->faction, "", fg, fgsnumber, NULL, this->serial );
                     } else {
                         Flightgroup *fg = caller->getFlightgroup();
                         int fgsnumber   = 0;
                         if (fg != NULL) {
                             fgsnumber = fg->nr_ships;
                             fg->nr_ships++;
                             fg->nr_ships_left++;
                         }
                         temp = UnitFactory::createUnit(
                             type->file.c_str(), false, caller->faction, "", fg, fgsnumber, NULL, this->serial );
                     }
                 }
                 Vector adder = Vector( mat.r[6], mat.r[7], mat.r[8] )*type->Speed;
                 temp->SetVelocity( caller->GetVelocity()+adder );
 
                 //Affect the stored mount serial to the new missile
                 temp->SetSerial( this->serial );
 
                 VSFileSystem::vs_dprintf( 3, "Creating missile with SERIAL ID %d\n", this->serial );
 
                 this->serial = 0;
                 if (target && target != owner) {
                     temp->Target( target );
                     temp->TargetTurret( target );
                     if (err <= Ok) {
                         temp->EnqueueAI( new AIScript( (type->file+".xai").c_str() ) );
                         temp->EnqueueAI( new Orders::FireAllYouGot );
                         if (match_speed_with_target)
                             temp->GetComputerData().velocity_ref.SetUnit( target );
                     } else {
                         temp->EnqueueAI( new Orders::AggressiveAI( "default.agg.xml" ) );
                         temp->SetTurretAI();
                         temp->TurretFAW();                         //turrets are for DEFENSE damnit!
                         temp->owner = caller;                         //spawned wingmen act as cargo (owned) wingmen, not as hired wingmen
                         float relat;
                         relat = caller->getRelation( target );
                         if (caller->isSubUnit() && relat >= 0) {
                             relat = -1;
                             temp->owner = caller->owner;
                         }
                         if (relat < 0) {
                             int i = 0;
                             while (relat < temp->getRelation( target ) && i++ < 100)
                                 GetMadAt( target, temp, 2 );
                         }
                         //pissed off                    getMadAt(target, 10); // how do I cause an attack here?
                     }
                 } else {
                     temp->EnqueueAI( new Orders::MatchLinearVelocity( Vector( 0, 0, 100000 ), true, false ) );
                     temp->EnqueueAI( new Orders::FireAllYouGot );
                 }
                 temp->SetOwner( (Unit*) owner );
                 temp->Velocity = velocity+adder;
                 temp->curr_physical_state = temp->prev_physical_state = temp->cumulative_transformation = tmp;
                 CopyMatrix( temp->cumulative_transformation_matrix, m );
                 _Universe->activeStarSystem()->AddUnit( temp );
                 temp->UpdateCollideQueue( _Universe->activeStarSystem(), hint );
                 for (unsigned int locind = 0; locind < Unit::NUM_COLLIDE_MAPS; ++locind)
                     if ( !is_null( temp->location[locind] ) )
                         hint[locind] = temp->location[locind];
             }
             break;
         }
         static bool   use_separate_sound    =
             XMLSupport::parse_bool( vs_config->getVariable( "audio", "high_quality_weapon", "true" ) );
         static bool   ai_use_separate_sound =
             XMLSupport::parse_bool( vs_config->getVariable( "audio", "ai_high_quality_weapon", "false" ) );
         static bool   ai_sound = XMLSupport::parse_bool( vs_config->getVariable( "audio", "ai_sound", "true" ) );
         Cockpit      *cp;
         bool ips = ( ( cp = _Universe->isPlayerStarshipVoid( owner ) ) != NULL );
         double distancesqr     = ( tmp.position-AUDListenerLocation() ).MagnitudeSquared();
         static double maxdistancesqr =
             XMLSupport::parse_float( vs_config->getVariable( "audio", "max_range_to_hear_weapon_fire",
                                                              "100000" ) )
             *XMLSupport::parse_float( vs_config->getVariable( "audio", "max_range_to_hear_weapon_fire", "100000" ) );
         static float weapon_gain = 
             XMLSupport::parse_float( vs_config->getVariable( "audio", "weapon_gain", ".25" ) );
         static float exterior_weapon_gain = 
             XMLSupport::parse_float( vs_config->getVariable( "audio", "exterior_weapon_gain", ".35" ) );
         static float min_weapon_sound_refire = 
             XMLSupport::parse_float( vs_config->getVariable( "audio", "min_weapon_sound_refire", ".2" ) );
         float curtime = realTime();
         bool tooquick = ((curtime - last_sound_refire_time) < min_weapon_sound_refire);
         if (!tooquick) {
             last_sound_refire_time = curtime;
             
             QVector sound_pos;
             Vector sound_vel;
             float sound_gain;
             
             if (ips && cp != NULL && cp->GetView() <= CP_RIGHT) {
                 sound_pos = QVector(0, 0, 0);
                 sound_vel = Vector(0, 0, 0);
                 sound_gain = weapon_gain;
             } else {
                 sound_pos = tmp.position;
                 sound_vel = velocity;
                 sound_gain = exterior_weapon_gain;
             }
             
             if ( ( ( (!use_separate_sound)
                     || type->type == weapon_info::BEAM )
                   || ( (!ai_use_separate_sound) && !ips ) ) && (isMissile( type ) == false) ) {
                 if ( ai_sound || (ips && type->type == weapon_info::BEAM) ) {
                     if ( !AUDIsPlaying( sound ) ) {
                         AUDPlay( sound, sound_pos, sound_vel, sound_gain );
                     } else {
                         if (distancesqr < maxdistancesqr) {
                             if (type->type == weapon_info::BEAM) {
                                 // Beams don't re-start, they keep playing
                                 AUDAdjustSound( sound, sound_pos, sound_vel );
                                 AUDSoundGain( sound, sound_gain );
                             } else {
                                 // Other kinds of weapons just re-play the sound
                                 AUDStopPlaying( sound );
                                 AUDPlay( sound, sound_pos, sound_vel, sound_gain );
                             }
                         } else {
                             AUDStopPlaying( sound );
                         }
                     }
                 }
             } else if ( (ai_sound || ips) && distancesqr < maxdistancesqr ) {
                 int snd = AUDCreateSound( sound, false );
                 AUDPlay( sound, sound_pos, sound_vel, sound_gain );
                 AUDDeleteSound( snd );
             }
         }
         return true;
     }
     return true;
 }

void Mount::PhysicsAlignedUnfire ( )

Fires a beam when the firing unit is at the Cumulative location/transformation owner (won't crash into) as owner and target as missile target. bool Missile indicates if it is a missile should it fire

Definition at line 475 of file mount.cpp.

References AUDIsPlaying(), AUDStopPlaying(), processed, sound, and UNFIRED.

 {
     //Stop Playing SOund?? No, that's done in the beam, must not be aligned
     if (processed == UNFIRED)
         if ( AUDIsPlaying( sound ) )
             AUDStopPlaying( sound );
 }

void Mount::ReplaceMounts	(	Unit *	unit,
		const Mount *	other
	)

Definition at line 120 of file mount.cpp.

References ammo, bank, weapon_info::BEAM, GetMountLocation(), GetMountOrientation(), Mount::REF::gun, q, ref, weapon_info::Refire(), Mount::REF::refire, ReplaceSound(), Unit::setAverageGunSpeed(), SetMountOrientation(), SetMountPosition(), size, weapon_info::type, type, v, Vector, volume, xyscale, and zscale.

 {
     int thisvol   = volume;     //short fix
     int thissize  = size;     //short fix
     float xyscale = this->xyscale;
     float zscale  = this->zscale;
     bool thisbank = this->bank;
     Quaternion q = this->GetMountOrientation();
     Vector     v = this->GetMountLocation();
     *this = *other;
     this->size    = thissize;
     volume        = thisvol;
     this->SetMountPosition( v );
     this->SetMountOrientation( q );
     this->xyscale = xyscale;
     this->zscale  = zscale;
     this->bank    = thisbank;
     ref.gun       = NULL;
     if (type->type != weapon_info::BEAM)
         ref.refire = type->Refire();
     this->ReplaceSound();
     if (other->ammo == -1)
         ammo = -1;
     else if (other->ammo != -1 && ammo == -1)
         ammo = 0;          //zero ammo if other was not zero earlier.
     un->setAverageGunSpeed();
 }

void Mount::ReplaceSound ( )

protected

Definition at line 483 of file mount.cpp.

References AUDCreateSound(), and sound.

Referenced by ReplaceMounts().

 {
     sound = AUDCreateSound( sound, false );     //copy constructor basically
 }

void Mount::SetMountOrientation ( const Quaternion & t)

Definition at line 74 of file unit_generic.cpp.

Referenced by AddMounts(), and ReplaceMounts().

 {
     orient = t;
 }

void Mount::SetMountPosition ( const Vector & v)

Definition at line 69 of file unit_generic.cpp.

References v.

Referenced by AddMounts(), and ReplaceMounts().

 {
     pos = v;
 }

void Mount::UnFire ( )

Definition at line 112 of file mount.cpp.

References ACTIVE, weapon_info::BEAM, Beam::Destabilize(), Mount::REF::gun, processed, ref, status, weapon_info::type, type, and UNFIRED.

Referenced by DestroyMount(), and Unit::Fire().

 {
     processed = UNFIRED;
     if (status != ACTIVE || ref.gun == NULL || type->type != weapon_info::BEAM)
         return;
     ref.gun->Destabilize();
 }