#include <DockEntity.h>

Inheritance diagram for DockEntity:

Collaboration diagram for DockEntity:

Instance Methods
(void)	- clear

(BOOL)	- allowsDocking

(void)	- setAllowsDocking:

(BOOL)	- disallowedDockingCollides

(void)	- setDisallowedDockingCollides:

(NSUInteger)	- countOfShipsInDockingQueue

(NSDictionary *)	- dockingInstructionsForShip:

(NSString *)	- canAcceptShipForDocking:

(BOOL)	- shipIsInDockingCorridor:

(BOOL)	- shipIsInDockingQueue:

(void)	- abortDockingForShip:

(void)	- abortAllDockings

(BOOL)	- dockingCorridorIsEmpty

(void)	- clearDockingCorridor

(void)	- autoDockShipsOnApproach

(NSUInteger)	- pruneAndCountShipsOnApproach

(void)	- noteDockingForShip:

(BOOL)	- allowsLaunching

(void)	- setAllowsLaunching:

(NSUInteger)	- countOfShipsInLaunchQueue

(NSUInteger)	- countOfShipsInLaunchQueueWithPrimaryRole:

(BOOL)	- allowsLaunchingOf:

(void)	- launchShip:

(void)	- addShipToLaunchQueue:withPriority:

(void)	- setDimensionsAndCorridor:docking:ddc:

(Vector)	- portUpVectorForShipsBoundingBox:

(BOOL)	- isOffCentre

(void)	- setVirtual

(void)	- abortAllLaunches `[implementation]`

(void)	- autoDockShipsInQueue: `[implementation]`

(void)	- addShipToShipsOnApproach: `[implementation]`

(void)	- pullInShipIfPermitted: `[implementation]`

(BOOL)	- isDock `[implementation]`

(id)	- initWithKey:definition: `[implementation]`

(void)	- dealloc `[implementation]`

(void)	- clearIdLocks: `[implementation]`

(void)	- clearAllIdLocks `[implementation]`

(BOOL)	- setUpShipFromDictionary: `[implementation]`

(void)	- update: `[implementation]`

(void)	- noteTakingDamage:from:type: `[implementation]`

(void)	- takeEnergyDamage:from:becauseOf:weaponIdentifier: `[implementation]`

(void)	- drawImmediate:translucent: `[implementation]`

(void)	- getJSClass:andPrototype: `[implementation]`

(NSString *)	- oo_jsClassName `[implementation]`

Instance Methods inherited from ShipEntity
(void)	- setStateMachine:

(void)	- setAI:

(AI *)	- getAI

(BOOL)	- hasAutoAI

(BOOL)	- hasNewAI

(void)	- setShipScript:

(void)	- removeScript

(OOScript *)	- shipScript

(OOScript *)	- shipAIScript

(OOTimeAbsolute)	- shipAIScriptWakeTime

(void)	- setAIScriptWakeTime:

(double)	- frustration

(void)	- setLaunchDelay:

(void)	- interpretAIMessage:

(GLfloat)	- accuracy

(void)	- setAccuracy:

(OOMesh *)	- mesh

(void)	- setMesh:

(BoundingBox)	- totalBoundingBox

(Vector)	- forwardVector

(Vector)	- upVector

(Vector)	- rightVector

(NSArray *)	- subEntities

(NSUInteger)	- subEntityCount

(BOOL)	- hasSubEntity:

(NSEnumerator *)	- subEntityEnumerator

(NSEnumerator *)	- shipSubEntityEnumerator

(NSEnumerator *)	- flasherEnumerator

(NSEnumerator *)	- exhaustEnumerator

(ShipEntity *)	- subEntityTakingDamage

(void)	- setSubEntityTakingDamage:

(void)	- clearSubEntities

(Quaternion)	- subEntityRotationalVelocity

(void)	- setSubEntityRotationalVelocity:

(NSString *)	- serializeShipSubEntities

(void)	- deserializeShipSubEntitiesFrom:

(NSUInteger)	- maxShipSubEntities

(void)	- setSubIdx:

(NSUInteger)	- subIdx

(Octree *)	- octree

(float)	- volume

(GLfloat)	- doesHitLine:v0:

(GLfloat)	- doesHitLine:v0:v1:

(GLfloat)	- doesHitLine:v0:withPosition:andIJK:i:j:

(BoundingBox)	- findBoundingBoxRelativeToPosition:InVectors:i:j:

(HPVector)	- absoluteTractorPosition

(void)	- setIsBoulder:

(BOOL)	- isBoulder

(BOOL)	- isMinable

(BOOL)	- countsAsKill

(void)	- setUpEscorts

(void)	- updateEscortFormation

(BOOL)	- setUpFromDictionary:

(BOOL)	- setUpSubEntities

(BOOL)	- setUpOneStandardSubentity:asTurret:

(GLfloat)	- frustumRadius

(NSString *)	- shipDataKey

(NSString *)	- shipDataKeyAutoRole

(void)	- setShipDataKey:

(NSDictionary *)	- shipInfoDictionary

(NSArray *)	- getWeaponOffsetFrom:withKey:inMode:

(NSArray *)	- aftWeaponOffset

(NSArray *)	- forwardWeaponOffset

(NSArray *)	- portWeaponOffset

(NSArray *)	- starboardWeaponOffset

(BOOL)	- hasAutoWeapons

(BOOL)	- isFrangible

(BOOL)	- suppressFlightNotifications

(void)	- respondToAttackFrom:becauseOf:

(OOWeaponFacingSet)	- weaponFacings

(BOOL)	- hasEquipmentItem:includeWeapons:whileLoading:

(BOOL)	- hasEquipmentItem:

(NSUInteger)	- countEquipmentItem:

(NSString *)	- equipmentItemProviding:

(BOOL)	- hasEquipmentItemProviding:

(BOOL)	- hasAllEquipment:includeWeapons:whileLoading:

(BOOL)	- hasAllEquipment:

(BOOL)	- setWeaponMount:toWeapon:

(BOOL)	- canAddEquipment:inContext:

(BOOL)	- equipmentValidToAdd:inContext:

(BOOL)	- equipmentValidToAdd:whileLoading:inContext:

(BOOL)	- addEquipmentItem:inContext:

(BOOL)	- addEquipmentItem:withValidation:inContext:

(BOOL)	- hasHyperspaceMotor

(float)	- hyperspaceSpinTime

(void)	- setHyperspaceSpinTime:

(NSEnumerator *)	- equipmentEnumerator

(NSUInteger)	- equipmentCount

(void)	- removeEquipmentItem:

(void)	- removeAllEquipment

(OOEquipmentType *)	- selectMissile

(OOCreditsQuantity)	- removeMissiles

(BOOL)	- hasOneEquipmentItem:includeWeapons:whileLoading:

(BOOL)	- hasOneEquipmentItem:includeMissiles:whileLoading:

(BOOL)	- hasPrimaryWeapon:

(BOOL)	- removeExternalStore:

(NSUInteger)	- parcelCount

(NSUInteger)	- passengerCount

(NSUInteger)	- passengerCapacity

(NSUInteger)	- missileCount

(NSUInteger)	- missileCapacity

(NSUInteger)	- extraCargo

(BOOL)	- hasScoop

(BOOL)	- hasFuelScoop

(BOOL)	- hasCargoScoop

(BOOL)	- hasECM

(BOOL)	- hasCloakingDevice

(BOOL)	- hasMilitaryScannerFilter

(BOOL)	- hasMilitaryJammer

(BOOL)	- hasExpandedCargoBay

(BOOL)	- hasShieldBooster

(BOOL)	- hasMilitaryShieldEnhancer

(BOOL)	- hasHeatShield

(BOOL)	- hasFuelInjection

(BOOL)	- hasCascadeMine

(BOOL)	- hasEscapePod

(BOOL)	- hasDockingComputer

(BOOL)	- hasGalacticHyperdrive

(float)	- shieldBoostFactor

(float)	- maxForwardShieldLevel

(float)	- maxAftShieldLevel

(float)	- shieldRechargeRate

(double)	- maxHyperspaceDistance

(float)	- afterburnerFactor

(float)	- afterburnerRate

(void)	- setAfterburnerFactor:

(void)	- setAfterburnerRate:

(float)	- maxThrust

(float)	- thrust

(void)	- setMaxThrust:

(void)	- setMaxFlightPitch:

(void)	- setMaxFlightSpeed:

(void)	- setMaxFlightRoll:

(void)	- setMaxFlightYaw:

(void)	- setEnergyRechargeRate:

(void)	- processBehaviour:

(void)	- behaviour_stop_still:

(void)	- behaviour_idle:

(void)	- behaviour_tumble:

(void)	- behaviour_tractored:

(void)	- behaviour_track_target:

(void)	- behaviour_intercept_target:

(void)	- behaviour_attack_target:

(void)	- behaviour_attack_slow_dogfight:

(void)	- behaviour_evasive_action:

(void)	- behaviour_attack_break_off_target:

(void)	- behaviour_fly_to_target_six:

(void)	- behaviour_attack_mining_target:

(void)	- behaviour_attack_fly_to_target:

(void)	- behaviour_attack_fly_from_target:

(void)	- behaviour_running_defense:

(void)	- behaviour_flee_target:

(void)	- behaviour_attack_broadside:

(void)	- behaviour_attack_broadside_left:

(void)	- behaviour_attack_broadside_right:

(void)	- behaviour_close_to_broadside_range:

(void)	- behaviour_close_with_target:

(void)	- behaviour_attack_broadside_target:leftside:

(void)	- behaviour_attack_sniper:

(void)	- behaviour_fly_range_from_destination:

(void)	- behaviour_face_destination:

(void)	- behaviour_land_on_planet:

(void)	- behaviour_formation_form_up:

(void)	- behaviour_fly_to_destination:

(void)	- behaviour_fly_from_destination:

(void)	- behaviour_avoid_collision:

(void)	- behaviour_track_as_turret:

(void)	- behaviour_fly_thru_navpoints:

(void)	- behaviour_scripted_ai:

(float)	- reactionTime

(void)	- setReactionTime:

(HPVector)	- calculateTargetPosition

(void)	- startTrackingCurve

(void)	- updateTrackingCurve

(void)	- calculateTrackingCurve

(GLfloat *)	- scannerDisplayColorForShip:otherShip:isHostile:flash:scannerDisplayColor1:scannerDisplayColor2:scannerDisplayColorH1:

(void)	- setScannerDisplayColor1:

(void)	- setScannerDisplayColor2:

(OOColor *)	- scannerDisplayColor1

(OOColor *)	- scannerDisplayColor2

(void)	- setScannerDisplayColorHostile1:

(void)	- setScannerDisplayColorHostile2:

(OOColor *)	- scannerDisplayColorHostile1

(OOColor *)	- scannerDisplayColorHostile2

(BOOL)	- isCloaked

(void)	- setCloaked:

(BOOL)	- hasAutoCloak

(void)	- setAutoCloak:

(void)	- applyThrust:

(void)	- applyAttitudeChanges:

(void)	- avoidCollision

(void)	- resumePostProximityAlert

(double)	- messageTime

(void)	- setMessageTime:

(OOShipGroup *)	- group

(void)	- setGroup:

(OOShipGroup *)	- escortGroup

(void)	- setEscortGroup:

(OOShipGroup *)	- stationGroup

(BOOL)	- hasEscorts

(NSEnumerator *)	- escortEnumerator

(NSArray *)	- escortArray

(uint8_t)	- escortCount

(uint8_t)	- pendingEscortCount

(void)	- setPendingEscortCount:

(uint8_t)	- maxEscortCount

(void)	- setMaxEscortCount:

(NSUInteger)	- turretCount

(NSString *)	- name

(NSString *)	- shipUniqueName

(NSString *)	- shipClassName

(NSString *)	- displayName

(NSString *)	- scanDescription

(NSString *)	- scanDescriptionForScripting

(void)	- setName:

(void)	- setShipUniqueName:

(void)	- setShipClassName:

(void)	- setDisplayName:

(void)	- setScanDescription:

(NSString *)	- identFromShip:

(BOOL)	- hasRole:

(OORoleSet *)	- roleSet

(void)	- addRole:

(void)	- addRole:withProbability:

(void)	- removeRole:

(NSString *)	- primaryRole

(void)	- setPrimaryRole:

(BOOL)	- hasPrimaryRole:

(BOOL)	- isPolice

(BOOL)	- isThargoid

(BOOL)	- isTrader

(BOOL)	- isPirate

(BOOL)	- isMissile

(BOOL)	- isMine

(BOOL)	- isWeapon

(BOOL)	- isEscort

(BOOL)	- isShuttle

(BOOL)	- isTurret

(BOOL)	- isPirateVictim

(BOOL)	- isExplicitlyUnpiloted

(BOOL)	- isUnpiloted

(OOAlertCondition)	- alertCondition

(OOAlertCondition)	- realAlertCondition

(BOOL)	- hasHostileTarget

(BOOL)	- isHostileTo:

(NSUInteger)	- defenseTargetCount

(NSArray *)	- allDefenseTargets

(NSEnumerator *)	- defenseTargetEnumerator

(void)	- validateDefenseTargets

(BOOL)	- addDefenseTarget:

(BOOL)	- isDefenseTarget:

(void)	- removeDefenseTarget:

(void)	- removeAllDefenseTargets

(NSArray *)	- collisionExceptions

(void)	- addCollisionException:

(void)	- removeCollisionException:

(BOOL)	- collisionExceptedFor:

(GLfloat)	- weaponRange

(void)	- setWeaponRange:

(void)	- setWeaponDataFromType:

(float)	- energyRechargeRate

(float)	- weaponRechargeRate

(void)	- setWeaponRechargeRate:

(void)	- setWeaponEnergy:

(OOWeaponFacing)	- currentWeaponFacing

(GLfloat)	- scannerRange

(void)	- setScannerRange:

(Vector)	- reference

(void)	- setReference:

(BOOL)	- reportAIMessages

(void)	- setReportAIMessages:

(void)	- transitionToAegisNone

(OOPlanetEntity *)	- findNearestPlanet

(Entity< OOStellarBody > *)	- findNearestStellarBody

(OOPlanetEntity *)	- findNearestPlanetExcludingMoons

(OOAegisStatus)	- checkForAegis

(void)	- forceAegisCheck

(BOOL)	- withinStationAegis

(void)	- setLastAegisLock:

(OOSystemID)	- homeSystem

(OOSystemID)	- destinationSystem

(void)	- setHomeSystem:

(void)	- setDestinationSystem:

(NSArray *)	- crew

(NSArray *)	- crewForScripting

(void)	- setCrew:

(void)	- setSingleCrewWithRole:

(OOFuelQuantity)	- fuel

(void)	- setFuel:

(OOFuelQuantity)	- fuelCapacity

(GLfloat)	- fuelChargeRate

(void)	- setRoll:

(void)	- setRawRoll:

(void)	- setPitch:

(void)	- setYaw:

(void)	- setThrust:

(void)	- applySticks:

(void)	- setThrustForDemo:

(void)	- setBounty:

(void)	- setBounty:withReason:

(void)	- setBounty:withReasonAsString:

(OOCreditsQuantity)	- bounty

(int)	- legalStatus

(BOOL)	- isTemplateCargoPod

(void)	- setUpCargoType:

(void)	- setCommodity:andAmount:

(void)	- setCommodityForPod:andAmount:

(OOCommodityType)	- commodityType

(OOCargoQuantity)	- commodityAmount

(OOCargoQuantity)	- maxAvailableCargoSpace

(void)	- setMaxAvailableCargoSpace:

(OOCargoQuantity)	- availableCargoSpace

(OOCargoQuantity)	- cargoQuantityOnBoard

(OOCargoType)	- cargoType

(NSArray *)	- cargoListForScripting

(NSMutableArray *)	- cargo

(void)	- setCargo:

(BOOL)	- addCargo:

(BOOL)	- removeCargo:amount:

(BOOL)	- showScoopMessage

(NSArray *)	- passengerListForScripting

(NSArray *)	- parcelListForScripting

(NSArray *)	- contractListForScripting

(NSArray *)	- equipmentListForScripting

(OOWeaponType)	- weaponTypeIDForFacing:strict:

(OOEquipmentType *)	- weaponTypeForFacing:strict:

(NSArray *)	- missilesList

(OOCargoFlag)	- cargoFlag

(void)	- setCargoFlag:

(void)	- setSpeed:

(double)	- desiredSpeed

(void)	- setDesiredSpeed:

(double)	- desiredRange

(void)	- setDesiredRange:

(double)	- cruiseSpeed

(Vector)	- thrustVector

(void)	- setTotalVelocity:

(void)	- increase_flight_speed:

(void)	- decrease_flight_speed:

(void)	- increase_flight_roll:

(void)	- decrease_flight_roll:

(void)	- increase_flight_pitch:

(void)	- decrease_flight_pitch:

(void)	- increase_flight_yaw:

(void)	- decrease_flight_yaw:

(GLfloat)	- flightRoll

(GLfloat)	- flightPitch

(GLfloat)	- flightYaw

(GLfloat)	- flightSpeed

(GLfloat)	- maxFlightPitch

(GLfloat)	- maxFlightSpeed

(GLfloat)	- maxFlightRoll

(GLfloat)	- maxFlightYaw

(GLfloat)	- speedFactor

(GLfloat)	- temperature

(void)	- setTemperature:

(GLfloat)	- heatInsulation

(void)	- setHeatInsulation:

(float)	- randomEjectaTemperature

(float)	- randomEjectaTemperatureWithMaxFactor:

(int)	- damage

(void)	- dealEnergyDamage:atRange:withBias:

(void)	- dealEnergyDamageWithinDesiredRange

(void)	- dealMomentumWithinDesiredRange:

(void)	- noteKilledBy:damageType:

(void)	- getDestroyedBy:damageType:

(void)	- becomeExplosion

(void)	- becomeLargeExplosion:

(void)	- becomeEnergyBlast

(void)	- broadcastEnergyBlastImminent

(void)	- setIsWreckage:

(BOOL)	- showDamage

(Vector)	- positionOffsetForAlignment:

(Vector)	- positionOffsetForShipInRotationToAlignment

(void)	- collectBountyFor:

(BoundingBox)	- findSubentityBoundingBox

(Triangle)	- absoluteIJKForSubentity

(GLfloat)	- weaponRecoveryTime

(GLfloat)	- laserHeatLevel

(GLfloat)	- laserHeatLevelAft

(GLfloat)	- laserHeatLevelForward

(GLfloat)	- laserHeatLevelPort

(GLfloat)	- laserHeatLevelStarboard

(GLfloat)	- hullHeatLevel

(GLfloat)	- entityPersonality

(GLint)	- entityPersonalityInt

(void)	- setEntityPersonalityInt:

(void)	- setSuppressExplosion:

(void)	- resetExhaustPlumes

(void)	- removeExhaust:

(void)	- removeFlasher:

(void)	- checkScanner

(void)	- checkScannerIgnoringUnpowered

(ShipEntity **)	- scannedShips

(int)	- numberOfScannedShips

(Entity *)	- foundTarget

(Entity *)	- primaryAggressor

(Entity *)	- lastEscortTarget

(Entity *)	- thankedShip

(Entity *)	- rememberedShip

(Entity *)	- proximityAlert

(void)	- setFoundTarget:

(void)	- setPrimaryAggressor:

(void)	- setLastEscortTarget:

(void)	- setThankedShip:

(void)	- setRememberedShip:

(void)	- setProximityAlert:

(void)	- setTargetStation:

(BOOL)	- isValidTarget:

(void)	- addTarget:

(void)	- removeTarget:

(BOOL)	- canStillTrackPrimaryTarget

(id)	- primaryTarget

(id)	- primaryTargetWithoutValidityCheck

(StationEntity *)	- targetStation

(BOOL)	- isFriendlyTo:

(ShipEntity *)	- shipHitByLaser

(void)	- noteLostTarget

(void)	- noteLostTargetAndGoIdle

(void)	- noteTargetDestroyed:

(OOBehaviour)	- behaviour

(void)	- setBehaviour:

(void)	- trackOntoTarget:withDForward:

(double)	- ballTrackLeadingTarget:atTarget:

(GLfloat)	- rollToMatchUp:rotating:

(GLfloat)	- rangeToDestination

(double)	- trackDestination:delta_t:

(void)	- setCoordinate:

(HPVector)	- coordinates

(HPVector)	- destination

(HPVector)	- distance_six:

(HPVector)	- distance_twelve:withOffset:

(void)	- setEvasiveJink:

(void)	- evasiveAction:

(double)	- trackPrimaryTarget:delta_t:

(double)	- trackSideTarget:delta_t:

(double)	- missileTrackPrimaryTarget:

(double)	- rangeToPrimaryTarget

(double)	- approachAspectToPrimaryTarget

(double)	- rangeToSecondaryTarget:

(BOOL)	- hasProximityAlertIgnoringTarget:

(GLfloat)	- currentAimTolerance

(GLfloat)	- lookingAtSunWithThresholdAngleCos:

(BOOL)	- onTarget:withWeapon:

(OOTimeDelta)	- shotTime

(void)	- resetShotTime

(BOOL)	- fireMainWeapon:

(BOOL)	- fireAftWeapon:

(BOOL)	- firePortWeapon:

(BOOL)	- fireStarboardWeapon:

(BOOL)	- fireTurretCannon:

(void)	- setLaserColor:

(void)	- setExhaustEmissiveColor:

(OOColor *)	- laserColor

(OOColor *)	- exhaustEmissiveColor

(BOOL)	- fireSubentityLaserShot:

(BOOL)	- fireDirectLaserShot:

(BOOL)	- fireDirectLaserDefensiveShot

(BOOL)	- fireDirectLaserShotAt:

(NSArray *)	- laserPortOffset:

(BOOL)	- fireLaserShotInDirection:weaponIdentifier:

(void)	- adjustMissedShots:

(int)	- missedShots

(void)	- considerFiringMissile:

(Vector)	- missileLaunchPosition

(ShipEntity *)	- fireMissile

(ShipEntity *)	- fireMissileWithIdentifier:andTarget:

(BOOL)	- isMissileFlagSet

(void)	- setIsMissileFlag:

(OOTimeDelta)	- missileLoadTime

(void)	- setMissileLoadTime:

(void)	- noticeECM

(BOOL)	- fireECM

(BOOL)	- cascadeIfAppropriateWithDamageAmount:cascadeOwner:

(BOOL)	- activateCloakingDevice

(void)	- deactivateCloakingDevice

(BOOL)	- launchCascadeMine

(ShipEntity *)	- launchEscapeCapsule

(OOCommodityType)	- dumpCargo

(ShipEntity *)	- dumpCargoItem:

(OOCargoType)	- dumpItem:

(void)	- manageCollisions

(BOOL)	- collideWithShip:

(void)	- adjustVelocity:

(void)	- addImpactMoment:fraction:

(BOOL)	- canScoop:

(void)	- getTractoredBy:

(void)	- scoopIn:

(void)	- scoopUp:

(void)	- scoopUpProcess:processEvents:processMessages:

(BOOL)	- abandonShip

(void)	- takeScrapeDamage:from:

(void)	- takeHeatDamage:

(void)	- enterDock:

(void)	- leaveDock:

(void)	- enterWormhole:

(void)	- enterWormhole:replacing:

(void)	- enterWitchspace

(void)	- leaveWitchspace

(BOOL)	- witchspaceLeavingEffects

(void)	- markAsOffender:

(void)	- markAsOffender:withReason:

(void)	- switchLightsOn

(void)	- switchLightsOff

(BOOL)	- lightsActive

(void)	- setDestination:

(void)	- setEscortDestination:

(BOOL)	- canAcceptEscort:

(BOOL)	- acceptAsEscort:

(void)	- deployEscorts

(void)	- dockEscorts

(void)	- setTargetToNearestFriendlyStation

(void)	- setTargetToNearestStation

(void)	- setTargetToSystemStation

(void)	- landOnPlanet:

(void)	- abortDocking

(NSDictionary *)	- dockingInstructions

(void)	- broadcastThargoidDestroyed

(void)	- broadcastHitByLaserFrom:

(GLfloat)	- sunGlareFilter

(void)	- setSunGlareFilter:

(void)	- sendExpandedMessage:toShip:

(void)	- sendMessage:toShip:withUnpilotedOverride:

(void)	- broadcastAIMessage:

(void)	- broadcastMessage:withUnpilotedOverride:

(void)	- setCommsMessageColor

(void)	- receiveCommsMessage:from:

(void)	- commsMessage:withUnpilotedOverride:

(BOOL)	- markedForFines

(BOOL)	- markForFines

(BOOL)	- isMining

(void)	- spawn:

(int)	- checkShipsInVicinityForWitchJumpExit

(BOOL)	- trackCloseContacts

(void)	- setTrackCloseContacts:

(void)	- setHulk:

(BOOL)	- isHulk

(OOJSScript *)	- script

(NSDictionary *)	- scriptInfo

(void)	- overrideScriptInfo:

(BOOL)	- scriptedMisjump

(void)	- setScriptedMisjump:

(GLfloat)	- scriptedMisjumpRange

(void)	- setScriptedMisjumpRange:

(Entity *)	- entityForShaderProperties

(void)	- setDemoShip:

(BOOL)	- isDemoShip

(void)	- setDemoStartTime:

(void)	- doScriptEvent:

(void)	- doScriptEvent:withArgument:

(void)	- doScriptEvent:withArgument:andArgument:

(void)	- doScriptEvent:withArguments:

(void)	- doScriptEvent:withArguments:count:

(void)	- doScriptEvent:inContext:withArguments:count:

(void)	- reactToAIMessage:context:

(void)	- sendAIMessage:

(void)	- doScriptEvent:andReactToAIMessage:

(void)	- doScriptEvent:withArgument:andReactToAIMessage:

(id)	- init `[implementation]`

(id)	- initBypassForPlayer `[implementation]`

(NSString *)	- repeatString:times: `[implementation]`

(BOOL)	- setUpOneSubentity: `[implementation]`

(BOOL)	- setUpOneFlasher: `[implementation]`

(NSString *)	- descriptionComponents `[implementation]`

(NSString *)	- shortDescriptionComponents `[implementation]`

(BoundingBox)	- findBoundingBoxRelativeToPosition:InVectors:_i:_j: `[implementation]`

(void)	- wasAddedToUniverse `[implementation]`

(void)	- wasRemovedFromUniverse `[implementation]`

(NSString *)	- beaconCode `[implementation]`

(void)	- setBeaconCode: `[implementation]`

(NSString *)	- beaconLabel `[implementation]`

(void)	- setBeaconLabel: `[implementation]`

(BOOL)	- isVisible `[implementation]`

(BOOL)	- isBeacon `[implementation]`

(id< OOHUDBeaconIcon >)	- beaconDrawable `[implementation]`

(Entity< OOBeaconEntity > *)	- prevBeacon `[implementation]`

(Entity< OOBeaconEntity > *)	- nextBeacon `[implementation]`

(void)	- setPrevBeacon: `[implementation]`

(void)	- setNextBeacon: `[implementation]`

(void)	- setUpMixedEscorts `[implementation]`

(void)	- setUpOneEscort:inGroup:withRole:atPosition:andCount: `[implementation]`

(OOScanClass)	- scanClass `[implementation]`

(BOOL)	- canCollide `[implementation]`

(ShipEntity *)	- doOctreesCollide `[implementation]`

(BOOL)	- checkCloseCollisionWith: `[implementation]`

(void)	- addSubentityToCollisionRadius: `[implementation]`

(ShipEntity *)	- launchPodWithCrew: `[implementation]`

(BOOL)	- validForAddToUniverse `[implementation]`

(void)	- noteFrustration: `[implementation]`

(OOEquipmentType *)	- generateMissileEquipmentTypeFrom: `[implementation]`

(OOEquipmentType *)	- verifiedMissileTypeFromRole: `[implementation]`

(void)	- drawDebugStuff `[implementation]`

(void)	- drawSubEntityImmediate:translucent: `[implementation]`

(BOOL)	- isJammingScanning `[implementation]`

(void)	- addSubEntity: `[implementation]`

(void)	- setOwner: `[implementation]`

(void)	- orientationChanged `[implementation]`

(void)	- applyRoll:andClimb: `[implementation]`

(void)	- applyRoll:climb:andYaw: `[implementation]`

(OOShipGroup *)	- rawEscortGroup `[implementation]`

(NSComparisonResult)	- ComparePlanetsBySurfaceDistance `[implementation]`

(Entity< OOStellarBody > *)	- lastAegisLock `[implementation]`

(void)	- setStatus: `[implementation]`

(void)	- rescaleBy: `[implementation]`

(void)	- rescaleBy:writeToCache: `[implementation]`

(void)	- releaseCargoPodsDebris `[implementation]`

(void)	- subEntityDied: `[implementation]`

(void)	- subEntityReallyDied: `[implementation]`

(NSComparisonResult)	- compareBeaconCodeWith: `[implementation]`

(uint32_t)	- randomSeedForShaders `[implementation]`

(void)	- setShipHitByLaser: `[implementation]`

(BOOL)	- fireWeapon:direction:range: `[implementation]`

(void)	- throwSparks `[implementation]`

(Vector)	- velocity `[implementation]`

(void)	- suppressTargetLost `[implementation]`

(void)	- refreshEscortPositions `[implementation]`

(HPVector)	- coordinatesForEscortPosition: `[implementation]`

(void)	- setTargetToNearestStationIncludingHostiles: `[implementation]`

(BoundingBox)	- findBoundingBoxRelativeTo:InVectors:_i:_j: `[implementation]`

(void)	- dumpSelfState `[implementation]`

(OOTimeAbsolute)	- getDemoStartTime `[implementation]`

(void)	- doNothing `[implementation]`

(NSString *)	- descriptionForObjDump `[implementation]`

(void)	- setAITo:

(void)	- setAIScript:

(void)	- switchAITo:

(void)	- scanForHostiles

(BOOL)	- performHyperSpaceToSpecificSystem:

(void)	- scanForNearestIncomingMissile

(void)	- enterTargetWormhole

(void)	- enterPlayerWormhole

(void)	- wormholeEscorts

(void)	- wormholeEntireGroup

(BOOL)	- suggestEscortTo:

(void)	- groupAttackTarget

(void)	- performAttack

(void)	- performCollect

(void)	- performEscort

(void)	- performFaceDestination

(void)	- performFlee

(void)	- performFlyToRangeFromDestination

(void)	- performHold

(void)	- performIdle

(void)	- performIntercept

(void)	- performLandOnPlanet

(void)	- performMining

(void)	- performScriptedAI

(void)	- performScriptedAttackAI

(void)	- performStop

(void)	- performTumble

(void)	- broadcastDistressMessage

(void)	- broadcastDistressMessageWithDumping:

(void)	- requestDockingCoordinates

(void)	- recallDockingInstructions

(void)	- performBuoyTumble `[implementation]`

(NSDictionary *)	- savedShipDictionaryWithContext:

(void)	- simplifyShipdata:andGetDeletes: `[implementation]`

(void)	- checkFoundTarget `[implementation]`

(BOOL)	- performHyperSpaceExitReplace: `[implementation]`

(BOOL)	- performHyperSpaceExitReplace:toSystem: `[implementation]`

(void)	- scanForNearestShipWithPredicate:parameter: `[implementation]`

(void)	- scanForNearestShipWithNegatedPredicate:parameter: `[implementation]`

(void)	- acceptDistressMessageFrom: `[implementation]`

(BOOL)	- launchPatrol `[implementation]`

(NSArray *)	- subEntitiesForScript

(void)	- setTargetForScript:

(BOOL)	- isVisibleToScripts `[implementation]`

(void)	- setStateTo: `[implementation]`

(void)	- pauseAI: `[implementation]`

(void)	- randomPauseAI: `[implementation]`

(void)	- dropMessages: `[implementation]`

(void)	- debugDumpPendingMessages `[implementation]`

(void)	- setDestinationToCurrentLocation `[implementation]`

(void)	- setDesiredRangeTo: `[implementation]`

(void)	- setDesiredRangeForWaypoint `[implementation]`

(void)	- setSpeedTo: `[implementation]`

(void)	- setSpeedFactorTo: `[implementation]`

(void)	- setSpeedToCruiseSpeed `[implementation]`

(void)	- setThrustFactorTo: `[implementation]`

(void)	- setTargetToPrimaryAggressor `[implementation]`

(void)	- scanForNearestMerchantman `[implementation]`

(void)	- scanForRandomMerchantman `[implementation]`

(void)	- scanForLoot `[implementation]`

(void)	- scanForRandomLoot `[implementation]`

(void)	- setTargetToFoundTarget `[implementation]`

(void)	- checkForFullHold `[implementation]`

(void)	- getWitchspaceEntryCoordinates `[implementation]`

(void)	- setDestinationFromCoordinates `[implementation]`

(void)	- setCoordinatesFromPosition `[implementation]`

(void)	- fightOrFleeMissile `[implementation]`

(void)	- setCourseToPlanet `[implementation]`

(void)	- setTakeOffFromPlanet `[implementation]`

(void)	- landOnPlanet `[implementation]`

(void)	- checkTargetLegalStatus `[implementation]`

(void)	- checkOwnLegalStatus `[implementation]`

(void)	- exitAIWithMessage: `[implementation]`

(void)	- setDestinationToTarget `[implementation]`

(void)	- setDestinationWithinTarget `[implementation]`

(void)	- checkCourseToDestination `[implementation]`

(void)	- checkAegis `[implementation]`

(void)	- checkEnergy `[implementation]`

(void)	- checkHeatInsulation `[implementation]`

(void)	- scanForOffenders `[implementation]`

(void)	- setCourseToWitchpoint `[implementation]`

(void)	- setDestinationToWitchpoint `[implementation]`

(void)	- setDestinationToStationBeacon `[implementation]`

(void)	- performHyperSpaceExit `[implementation]`

(void)	- performHyperSpaceExitWithoutReplacing `[implementation]`

(void)	- wormholeGroup `[implementation]`

(void)	- commsMessage: `[implementation]`

(void)	- commsMessageByUnpiloted: `[implementation]`

(void)	- ejectCargo `[implementation]`

(void)	- scanForThargoid `[implementation]`

(void)	- scanForNonThargoid `[implementation]`

(void)	- thargonCheckMother `[implementation]`

(void)	- becomeUncontrolledThargon `[implementation]`

(void)	- checkDistanceTravelled `[implementation]`

(void)	- fightOrFleeHostiles `[implementation]`

(void)	- suggestEscort `[implementation]`

(void)	- escortCheckMother `[implementation]`

(void)	- checkGroupOddsVersusTarget `[implementation]`

(void)	- scanForFormationLeader `[implementation]`

(void)	- messageMother: `[implementation]`

(void)	- setPlanetPatrolCoordinates `[implementation]`

(void)	- setSunSkimStartCoordinates `[implementation]`

(void)	- setSunSkimEndCoordinates `[implementation]`

(void)	- setSunSkimExitCoordinates `[implementation]`

(void)	- patrolReportIn `[implementation]`

(void)	- checkForMotherStation `[implementation]`

(void)	- sendTargetCommsMessage: `[implementation]`

(void)	- markTargetForFines `[implementation]`

(void)	- markTargetForOffence: `[implementation]`

(void)	- storeTarget `[implementation]`

(void)	- recallStoredTarget `[implementation]`

(void)	- scanForRocks `[implementation]`

(void)	- setDestinationToDockingAbort `[implementation]`

(void)	- requestNewTarget `[implementation]`

(void)	- rollD: `[implementation]`

(void)	- scanForNearestShipWithPrimaryRole: `[implementation]`

(void)	- scanForNearestShipHavingRole: `[implementation]`

(void)	- scanForNearestShipWithAnyPrimaryRole: `[implementation]`

(void)	- scanForNearestShipHavingAnyRole: `[implementation]`

(void)	- scanForNearestShipWithScanClass: `[implementation]`

(void)	- scanForNearestShipWithoutPrimaryRole: `[implementation]`

(void)	- scanForNearestShipNotHavingRole: `[implementation]`

(void)	- scanForNearestShipWithoutAnyPrimaryRole: `[implementation]`

(void)	- scanForNearestShipNotHavingAnyRole: `[implementation]`

(void)	- scanForNearestShipWithoutScanClass: `[implementation]`

(void)	- setCoordinates: `[implementation]`

(void)	- checkForNormalSpace `[implementation]`

(void)	- setTargetToRandomStation `[implementation]`

(void)	- setTargetToLastStation `[implementation]`

(void)	- addFuel: `[implementation]`

(void)	- scriptActionOnTarget: `[implementation]`

(void)	- sendScriptMessage: `[implementation]`

(void)	- ai_throwSparks `[implementation]`

(void)	- explodeSelf `[implementation]`

(void)	- ai_debugMessage: `[implementation]`

(void)	- targetFirstBeaconWithCode: `[implementation]`

(void)	- targetNextBeaconWithCode: `[implementation]`

(void)	- setRacepointsFromTarget `[implementation]`

(void)	- performFlyRacepoints `[implementation]`

(void)	- addPrimaryAggressorAsDefenseTarget `[implementation]`

(void)	- addFoundTargetAsDefenseTarget `[implementation]`

(void)	- findNewDefenseTarget `[implementation]`

(void)	- setDestinationToJinkPosition `[implementation]`

(void)	- disengageAutopilot `[implementation]`

(void)	- messageSelf: `[implementation]`

(void)	- scanForNearestShipMatchingPredicate: `[implementation]`

(void)	- safeScriptActionOnTarget: `[implementation]`

(ShipEntity *)	- ejectShipOfType:

(ShipEntity *)	- ejectShipOfRole:

(NSArray *)	- spawnShipsWithRole:count:

(BOOL)	- isShipWithSubEntityShip: `[implementation]`

Instance Methods inherited from OOEntityWithDrawable
(OODrawable *)	- drawable

(void)	- setDrawable:

(double)	- findCollisionRadius `[implementation]`

(NSSet *)	- allTextures `[implementation]`

Instance Methods inherited from Entity
(NSUInteger)	- sessionID

(BOOL)	- isShip

(BOOL)	- isStation

(BOOL)	- isSubEntity

(BOOL)	- isPlayer

(BOOL)	- isPlanet

(BOOL)	- isSun

(BOOL)	- isSunlit

(BOOL)	- isStellarObject

(BOOL)	- isSky

(BOOL)	- isWormhole

(BOOL)	- isEffect

(BOOL)	- isVisualEffect

(BOOL)	- isWaypoint

(void)	- addToLinkedLists

(void)	- removeFromLinkedLists

(void)	- updateLinkedLists

(void)	- warnAboutHostiles

(CollisionRegion *)	- collisionRegion

(void)	- setCollisionRegion:

(void)	- setUniversalID:

(OOUniversalID)	- universalID

(BOOL)	- throwingSparks

(void)	- setThrowSparks:

(id)	- owner

(ShipEntity *)	- parentEntity

(ShipEntity *)	- rootShipEntity

(void)	- setPosition:

(void)	- setPositionX:y:z:

(HPVector)	- position

(Vector)	- cameraRelativePosition

(GLfloat)	- cameraRangeFront

(GLfloat)	- cameraRangeBack

(void)	- updateCameraRelativePosition

(Vector)	- vectorTo:

(HPVector)	- absolutePositionForSubentity

(HPVector)	- absolutePositionForSubentityOffset:

(double)	- zeroDistance

(double)	- camZeroDistance

(NSComparisonResult)	- compareZeroDistance:

(BoundingBox)	- boundingBox

(GLfloat)	- mass

(Quaternion)	- orientation

(void)	- setOrientation:

(Quaternion)	- normalOrientation

(void)	- setNormalOrientation:

(void)	- setVelocity:

(double)	- speed

(GLfloat)	- distanceTravelled

(void)	- setDistanceTravelled:

(OOEntityStatus)	- status

(void)	- setScanClass:

(void)	- setEnergy:

(GLfloat)	- energy

(void)	- setMaxEnergy:

(GLfloat)	- maxEnergy

(void)	- moveForward:

(OOMatrix)	- rotationMatrix

(OOMatrix)	- drawRotationMatrix

(OOMatrix)	- transformationMatrix

(OOMatrix)	- drawTransformationMatrix

(GLfloat)	- collisionRadius

(void)	- setCollisionRadius:

(NSMutableArray *)	- collisionArray

(void)	- applyVelocity:

(void)	- dumpState

(NSUInteger)	- lastDrawCounter

(void)	- setLastDrawCounter:

(BOOL)	- isInSpace

(BOOL)	- isImmuneToBreakPatternHide

(GLfloat)	- universalTime

(GLfloat)	- spawnTime

(GLfloat)	- timeElapsedSinceSpawn

(void)	- setAtmosphereFogging:

(OOColor *)	- fogUniform

(NSString *)	- descriptionForObjDumpBasic

(BOOL)	- checkLinkedLists `[implementation]`

(id< OOWeakReferenceSupport >)	- superShaderBindingTarget `[implementation]`

(Vector)	- relativePosition `[implementation]`

(BOOL)	- isBreakPattern

(void)	- inspect `[implementation]`

(BOOL)	- isECMBlast

(BOOL)	- isExhaust

(BOOL)	- isFlasher

(void)	- deleteJSSelf

(jsval)	- oo_jsValueInContext: `[implementation]`

(BOOL)	- isCascadeWeapon

(BOOL)	- isPlayerLikeShip

(GLfloat)	- clock `[implementation]`

(unsigned)	- pseudoFixedD100 `[implementation]`

(unsigned)	- pseudoFixedD256 `[implementation]`

(unsigned)	- systemGovernment `[implementation]`

(unsigned)	- systemEconomy `[implementation]`

(unsigned)	- systemTechLevel `[implementation]`

(unsigned)	- systemPopulation `[implementation]`

(unsigned)	- systemProductivity `[implementation]`

Instance Methods inherited from OOWeakRefObject
(id)	- weakSelf

(id)	- weakRetain `[implementation]`

(void)	- weakRefDied: `[implementation]`

Instance Methods inherited from <OOWeakReferenceSupport>
(id)	- OO_RETURNS_RETAINED

Private Attributes
NSMutableDictionary *	shipsOnApproach

NSMutableArray *	launchQueue

double	last_launch_time

ShipEntity *	id_lock [MAX_DOCKING_STAGES]

Vector	port_dimensions

double	port_corridor

BOOL	no_docking_while_launching

BOOL	allow_launching

BOOL	allow_docking

BOOL	disallowed_docking_collides

BOOL	virtual_dock

Additional Inherited Members
Class Methods inherited from ShipEntity
(static BOOL)	+ IsBehaviourHostile `[implementation]`

(static float)	+ SurfaceDistanceSqaredV `[implementation]`

(static float)	+ SurfaceDistanceSqared `[implementation]`

(static BOOL)	+ AuthorityPredicate `[implementation]`

(id)	+ shipRestoredFromDictionary:useFallback:context:

Public Attributes inherited from ShipEntity
OOTimeDelta	shot_time

Vector	v_forward

Vector	v_up

Vector	v_right

HPVector	_destination

GLfloat	desired_range

GLfloat	desired_speed

GLfloat	stick_roll

GLfloat	stick_pitch

GLfloat	stick_yaw

OOBehaviour	behaviour

BoundingBox	totalBoundingBox

Public Attributes inherited from Entity
OOUniversalID	universalID

unsigned	isShip: 1

unsigned	isStation: 1

unsigned	isPlayer: 1

unsigned	isWormhole: 1

unsigned	isSubEntity: 1

unsigned	hasMoved: 1

unsigned	hasRotated: 1

unsigned	hasCollided: 1

unsigned	isSunlit: 1

unsigned	collisionTestFilter: 2

unsigned	throw_sparks: 1

unsigned	isImmuneToBreakPatternHide: 1

unsigned	isExplicitlyNotMainStation: 1

unsigned	isVisualEffect: 1

OOScanClass	scanClass

GLfloat	zero_distance

GLfloat	cam_zero_distance

GLfloat	no_draw_distance

GLfloat	collision_radius

HPVector	position

Vector	cameraRelativePosition

Quaternion	orientation

OOColor *	atmosphereFogging

int	zero_index

Entity *	x_previous

Entity *	x_next

Entity *	y_previous

Entity *	y_next

Entity *	z_previous

Entity *	z_next

Entity *	collision_chain

OOUniversalID	shadingEntityID

Entity *	collider

CollisionRegion *	collisionRegion

Protected Attributes inherited from ShipEntity
NSDictionary *	shipinfoDictionary

Quaternion	subentityRotationalVelocity

OOJSScript *	script

OOJSScript *	aiScript

OOTimeAbsolute	aiScriptWakeTime

NSDictionary *	dockingInstructions

OOColor *	laser_color

OOColor *	default_laser_color

OOColor *	exhaust_emissive_color

OOColor *	scanner_display_color1

OOColor *	scanner_display_color2

OOColor *	scanner_display_color_hostile1

OOColor *	scanner_display_color_hostile2

GLfloat	maxFlightSpeed

GLfloat	max_flight_roll

GLfloat	max_flight_pitch

GLfloat	max_flight_yaw

GLfloat	cruiseSpeed

GLfloat	max_thrust

GLfloat	thrust

float	hyperspaceMotorSpinTime

unsigned	military_jammer_active: 1

unsigned	docking_match_rotation: 1

unsigned	pitching_over: 1

unsigned	rolling_over: 1

unsigned	reportAIMessages: 1

unsigned	being_mined: 1

unsigned	being_fined: 1

unsigned	isHulk: 1

unsigned	trackCloseContacts: 1

unsigned	isNearPlanetSurface: 1

unsigned	isFrangible: 1

unsigned	cloaking_device_active: 1

unsigned	cloakPassive: 1

unsigned	cloakAutomatic: 1

unsigned	canFragment: 1

unsigned	isWreckage: 1

unsigned	_showDamage: 1

unsigned	suppressExplosion: 1

unsigned	suppressAegisMessages: 1

unsigned	isMissile: 1

unsigned	_explicitlyUnpiloted: 1

unsigned	hasScoopMessage: 1

unsigned	scripted_misjump: 1

unsigned	haveExecutedSpawnAction: 1

unsigned	haveStartedJSAI: 1

unsigned	noRocks: 1

unsigned	_lightsActive: 1

GLfloat	_scriptedMisjumpRange

GLfloat	sunGlareFilter

OOFuelQuantity	fuel

GLfloat	fuel_accumulator

GLfloat	afterburner_rate

GLfloat	afterburner_speed_factor

OOCargoQuantity	likely_cargo

OOCargoQuantity	max_cargo

OOCargoQuantity	extra_cargo

OOCargoQuantity	equipment_weight

OOCargoType	cargo_type

OOCargoFlag	cargo_flag

OOCreditsQuantity	bounty

GLfloat	energy_recharge_rate

OOWeaponFacingSet	weapon_facings

OOWeaponType	forward_weapon_type

OOWeaponType	aft_weapon_type

OOWeaponType	port_weapon_type

OOWeaponType	starboard_weapon_type

GLfloat	weapon_damage

GLfloat	weapon_damage_override

GLfloat	weaponRange

OOWeaponFacing	currentWeaponFacing

GLfloat	weapon_energy_use

GLfloat	weapon_temp

GLfloat	weapon_shot_temperature

GLfloat	forward_weapon_temp

GLfloat	aft_weapon_temp

GLfloat	port_weapon_temp

GLfloat	starboard_weapon_temp

GLfloat	scannerRange

unsigned	missiles

unsigned	max_missiles

NSString *	_missileRole

OOTimeDelta	missile_load_time

OOTimeAbsolute	missile_launch_time

AI *	shipAI

NSString *	name

NSString *	shipUniqueName

NSString *	shipClassName

NSString *	displayName

NSString *	scan_description

OORoleSet *	roleSet

NSString *	primaryRole

NSArray *	explosionType

Vector	jink

HPVector	coordinates

Vector	reference

NSUInteger	_subIdx

NSUInteger	_maxShipSubIdx

double	launch_time

double	launch_delay

OOUniversalID	planetForLanding

GLfloat	frustration

GLfloat	success_factor

int	patrol_counter

NSMutableDictionary *	previousCondition

float	weapon_recharge_rate

int	shot_counter

OOTimeAbsolute	cargo_dump_time

OOTimeAbsolute	last_shot_time

NSMutableArray *	cargo

OOCommodityType	commodity_type

OOCargoQuantity	commodity_amount

GLfloat	flightSpeed

GLfloat	flightRoll

GLfloat	flightPitch

GLfloat	flightYaw

GLfloat	accuracy

GLfloat	pitch_tolerance

GLfloat	aim_tolerance

int	_missed_shots

OOAegisStatus	aegis_status

OOSystemID	home_system

OOSystemID	destination_system

double	messageTime

double	next_spark_time

Vector	collision_vector

GLfloat	_scaleFactor

BOOL	_multiplyWeapons

NSArray *	forwardWeaponOffset

NSArray *	aftWeaponOffset

NSArray *	portWeaponOffset

NSArray *	starboardWeaponOffset

NSArray *	crew

NSMutableDictionary *	closeContactsInfo

NSString *	lastRadioMessage

Vector	tractor_position

float	ship_temperature

ShipEntity *	scanned_ships [MAX_SCAN_NUMBER+1]

GLfloat	distance2_scanned_ships [MAX_SCAN_NUMBER+1]

unsigned	n_scanned_ships

HPVector	navpoints [32]

unsigned	next_navpoint_index

unsigned	number_of_navpoints

Octree *	octree

OOBehaviour	debugLastBehaviour

uint16_t	entity_personality

NSDictionary *	scriptInfo

NSMutableArray *	subEntities

OOEquipmentType *	missile_list [SHIPENTITY_MAX_MISSILES]

OOWeakReference *	_primaryTarget

OOWeakReference *	_primaryAggressor

OOWeakReference *	_targetStation

OOWeakReference *	_foundTarget

OOWeakReference *	_lastEscortTarget

OOWeakReference *	_thankedShip

OOWeakReference *	_rememberedShip

OOWeakReference *	_proximityAlert

float	reactionTime

HPVector	trackingCurvePositions [4]

OOTimeAbsolute	trackingCurveTimes [4]

HPVector	trackingCurveCoeffs [3]

Protected Attributes inherited from Entity
HPVector	lastPosition

Quaternion	lastOrientation

GLfloat	distanceTravelled

OOMatrix	rotMatrix

Vector	velocity

GLfloat	energy

GLfloat	maxEnergy

BoundingBox	boundingBox

GLfloat	mass

NSMutableArray *	collidingEntities

OOTimeAbsolute	spawnTime

struct JSObject *	_jsSelf

NSUInteger	lastDrawCounter

Protected Attributes inherited from OOWeakRefObject
OOWeakReference *	weakSelf

Detailed Description

Definition at line 31 of file DockEntity.h.

Method Documentation

◆ abortAllDockings

- (void) abortAllDockings

Definition at line 1 of file DockEntity.m.

{
    double      playerExtraTime = 0;
    
    no_docking_while_launching = YES;
    
    NSNumber *idObj = nil;
    foreach (idObj, [shipsOnApproach allKeys])
    {
        ShipEntity *ship = [UNIVERSE entityForUniversalID:[idObj unsignedIntValue]];
        if ([ship isShip])
        {
            [ship sendAIMessage:@"DOCKING_ABORTED"];
            [ship doScriptEvent:OOJSID("stationWithdrewDockingClearance")];
        }
    }
    [shipsOnApproach removeAllObjects];
    
    PlayerEntity *player = PLAYER;
    StationEntity *station = (StationEntity*)[self parentEntity];
    BOOL isDockingStation = (station == [player getTargetDockStation]) && ([station playerReservedDock] == self);
    if (isDockingStation && [player status] == STATUS_IN_FLIGHT &&
            [player getDockingClearanceStatus] >= DOCKING_CLEARANCE_STATUS_REQUESTED)
    {
        if (HPmagnitude2(HPvector_subtract([player position], [self absolutePositionForSubentity])) > 2250000) // within 1500m of the dock
        {
            [station sendExpandedMessage:@"[station-docking-clearance-abort-cancelled]" toShip:player];
            [player setDockingClearanceStatus:DOCKING_CLEARANCE_STATUS_NONE];
            [player doScriptEvent:OOJSID("stationWithdrewDockingClearance")];
        }
        else
        {
            playerExtraTime = 10; // when very close to the port, give the player a few seconds to react on the abort message.
            int seconds = round(playerExtraTime);
            [station sendExpandedMessage:OOExpandKey(@"station-docking-clearance-abort-cancelled-in-time", seconds) toShip:player];
            [player setDockingClearanceStatus:DOCKING_CLEARANCE_STATUS_TIMING_OUT];
        }
 
    }
    
    // mark docking queue flight pattern as clear
    [self clearAllIdLocks];
 
    last_launch_time = [UNIVERSE getTime] + playerExtraTime;
}

◆ abortAllLaunches

- (void) abortAllLaunches

implementation

Definition at line 1 of file DockEntity.m.

{
    no_docking_while_launching = NO;
    [launchQueue removeAllObjects];
}

◆ abortDockingForShip:

- (void) abortDockingForShip: (ShipEntity *) ship

Definition at line 1 of file DockEntity.m.

                            :(ShipEntity *)ship
{
    OOUniversalID   ship_id = [ship universalID];
    NSNumber        *shipID = [NSNumber numberWithUnsignedShort:ship_id];
    
    if ([shipsOnApproach objectForKey:shipID])
    {
        [shipsOnApproach removeObjectForKey:shipID];
    }
    
    if ([ship isPlayer])
    {
        PlayerEntity* player = PLAYER;
        if ([player status] == STATUS_IN_FLIGHT &&
                [player getDockingClearanceStatus] >= DOCKING_CLEARANCE_STATUS_REQUESTED)
        {
            if (HPmagnitude2(HPvector_subtract([player position], [self absolutePositionForSubentity])) > 2250000) // within 1500m of the dock
            {
                [[self parentEntity] sendExpandedMessage:@"[station-docking-clearance-abort-cancelled]" toShip:player];
                [player setDockingClearanceStatus:DOCKING_CLEARANCE_STATUS_NONE];
            }
            else
            {
                int seconds = 10; // when very close to the port, give the player a few seconds to react on the abort message.
                [[self parentEntity] sendExpandedMessage:OOExpandKey(@"station-docking-clearance-abort-cancelled-in-time", seconds) toShip:player];
                [player setDockingClearanceStatus:DOCKING_CLEARANCE_STATUS_TIMING_OUT];
            }
        }
    }
 
    // clear any previously owned docking stages
    [self clearIdLocks:ship];
}

◆ addShipToLaunchQueue:withPriority:

- (void) addShipToLaunchQueue:	(ShipEntity *)	ship
withPriority:	(BOOL)	priority

Definition at line 1 of file DockEntity.m.

                             :(ShipEntity *)ship withPriority:(BOOL)priority
{
    [self pruneAndCountShipsOnApproach];
    
    if (ship == nil)  return;
    
    if (launchQueue == nil)
    {
        launchQueue = [[NSMutableArray alloc] init]; // retained
    }
    
    [ship setStatus:STATUS_DOCKED];
    if (priority)
    {
        [launchQueue insertObject:ship atIndex:0];
    }
    else
    {
        [launchQueue addObject:ship];
    }
}

◆ addShipToShipsOnApproach:

- (void) addShipToShipsOnApproach: (ShipEntity *) ship

implementation

Provided by category DockEntity(OOPrivate).

Definition at line 1 of file DockEntity.m.

                                 :(ShipEntity *) ship
{       
    int         corridor_distance[] =   {   -1, 1,  3,  5,  7,  9,  11, 12, 12};
    int         corridor_offset[] =     {   0,  0,  0,  0,  0,  0,  1,  3,  12};
    /* Eric's improvements to the docking flight code seem to have
     * made it safer to go quite a bit faster here. With the increased
     * numbers of ships which might need to dock at the main station,
     * faster docking will help avoid massive queues. Previous speed
     * was mostly 48 - CIM: 27/8/2013*/
    int         corridor_speed[] =      {   96, 96, 128,    128,    96, 128,    128,    256,    512};   // how fast to approach the next point
    int         corridor_range[] =      {   24, 12, 6,  4,  4,  6,  15, 38, 96};    // how close you have to get to the target point
    int         corridor_rotate[] =     {   1,  1,  1,  1,  0,  0,  0,  0,  0};     // whether to match the station rotation
    int         corridor_count = 9;
    int         corridor_final_approach = 3;
    
    NSNumber        *shipID = [NSNumber numberWithUnsignedShort:[ship universalID]];
    StationEntity   *station = (StationEntity *)[self parentEntity];
    
    HPVector launchVector = HPvector_forward_from_quaternion(quaternion_multiply(orientation, [station orientation]));
    HPVector temp = (fabs(launchVector.x) < 0.8)? make_HPvector(1,0,0) : make_HPvector(0,1,0);
    temp = HPcross_product(launchVector, temp); // 90 deg to launchVector & temp
    HPVector rightVector = HPcross_product(launchVector, temp);
    HPVector upVector = HPcross_product(launchVector, rightVector);
    
    // will select a direction for offset based on the entity personality (was ship ID)
    int offset_id = [ship entityPersonalityInt] & 0xf;  // 16  point compass
    double c = cos(offset_id * M_PI * ONE_EIGHTH);
    double s = sin(offset_id * M_PI * ONE_EIGHTH);
    
    // test if this points at the ship
    HPVector point1 = [self absolutePositionForSubentity];
    point1.x += launchVector.x * corridor_offset[corridor_count - 1];
    point1.y += launchVector.x * corridor_offset[corridor_count - 1];
    point1.z += launchVector.x * corridor_offset[corridor_count - 1];
    HPVector alt1 = point1;
    point1.x += c * upVector.x * corridor_offset[corridor_count - 1] + s * rightVector.x * corridor_offset[corridor_count - 1];
    point1.y += c * upVector.y * corridor_offset[corridor_count - 1] + s * rightVector.y * corridor_offset[corridor_count - 1];
    point1.z += c * upVector.z * corridor_offset[corridor_count - 1] + s * rightVector.z * corridor_offset[corridor_count - 1];
    alt1.x -= c * upVector.x * corridor_offset[corridor_count - 1] + s * rightVector.x * corridor_offset[corridor_count - 1];
    alt1.y -= c * upVector.y * corridor_offset[corridor_count - 1] + s * rightVector.y * corridor_offset[corridor_count - 1];
    alt1.z -= c * upVector.z * corridor_offset[corridor_count - 1] + s * rightVector.z * corridor_offset[corridor_count - 1];
    if (HPdistance2(alt1, ship->position) < HPdistance2(point1, ship->position))
    {
        s = -s;
        c = -c; // turn 180 degrees
    }
    
    //
    NSMutableArray *coordinatesStack = [NSMutableArray arrayWithCapacity: MAX_DOCKING_STAGES];
    float port_depth = port_dimensions.z;   // 250m deep standard port.
    
    int i;
    for (i = corridor_count - 1; i >= 0; i--)
    {
        NSMutableDictionary *nextCoords = [NSMutableDictionary dictionaryWithCapacity:3];
        int offset = corridor_offset[i];
        float corridor_length = port_depth * corridor_distance[i];
        
        float rx = s * port_depth * offset;
        float ry = c * port_depth * offset;
        float rz = corridor_length;
        // if there are many ships on approach, randomise coordinates a bit
        if ((i == corridor_count - 1) && [self countOfShipsInDockingQueue])
        {
            /* This used to try to just space the ships further out
             * along the 16 approach lanes - this had various problems
             * with putting ship coordinates on top of each other
             * and/or spacing them out all the way back to the
             * witchpoint. Instead, use a few more bits of
             * entityPersonalityInt to shuffle the holding coordinates
             * a bit more. It still doesn't guarantee two ships won't
             * want the same space, but it makes it considerably more
             * unlikely - I dropped 100 docking ships into the aegis
             * at once, and they all got allocated positions far
             * enough from the others to avoid collisions or near
             * misses - CIM: 27 May 2014 */
 
            int offset_id2 = ([ship entityPersonalityInt] & 0xf0)>>4;   // 16  point compass
            int offset_id3 = ([ship entityPersonalityInt] & 0xf00)>>8;  // 16  point step position
            float c2 = cos(offset_id2 * M_PI * ONE_EIGHTH);
            float s2 = sin(offset_id2 * M_PI * ONE_EIGHTH);
            float ssize = MAX(port_depth,1500.0);
            rx += c2 * ssize; 
            ry += s2 * ssize; 
            rz += ssize * ((float)offset_id3 / 4.0);
 
//          OOLog(@"docking.debug",@"Adjusted coordinates by %f x %f x %f",c2 * ssize,s2 * ssize,ssize * ((float)offset_id3 / 4.0));
        }
        
        // add the lenght inside the station to the corridor, except for the final position, inside the dock.
        if (corridor_distance[i] > 0)  corridor_length += port_corridor;
        
        [nextCoords oo_setInteger:corridor_count - i    forKey:@"docking_stage"];
        [nextCoords oo_setFloat:rx                      forKey:@"rx"];
        [nextCoords oo_setFloat:ry                      forKey:@"ry"];
        [nextCoords oo_setFloat:rz                      forKey:@"rz"];
        [nextCoords oo_setFloat:corridor_speed[i]       forKey:@"speed"];
        [nextCoords oo_setFloat:corridor_range[i]       forKey:@"range"];
        
        if (corridor_rotate[i])
        {
            [nextCoords setObject:@"YES" forKey:@"match_rotation"];
        }
        
        if (i == corridor_final_approach)
        {
            if (station == [UNIVERSE station])
            {
                [nextCoords setObject:@"[station-begin-final-aproach]" forKey:@"comms_message"];
            }
            else
            {
                [nextCoords setObject:@"[docking-begin-final-aproach]" forKey:@"comms_message"];
            }
        }
        
        [coordinatesStack addObject:nextCoords];
    }
    
    [shipsOnApproach setObject:coordinatesStack forKey:shipID];
    
    
    // COMM-CHATTER
    if (station == [UNIVERSE station])
    {
        [station sendExpandedMessage:@"[station-welcome]" toShip:ship];
    }
    else
    {
        [station sendExpandedMessage:@"[docking-welcome]" toShip:ship];
    }
}

◆ allowsDocking

- (BOOL) allowsDocking

Definition at line 1 of file DockEntity.m.

{
    return allow_docking;
}

◆ allowsLaunching

- (BOOL) allowsLaunching

Definition at line 1 of file DockEntity.m.

{
    return allow_launching;
}

◆ allowsLaunchingOf:

- (BOOL) allowsLaunchingOf: (ShipEntity *) ship

Definition at line 1 of file DockEntity.m.

                          :(ShipEntity *) ship
{
    if (![ship isShip])  return NO;
    
    BoundingBox bb = [ship totalBoundingBox];
    if ((port_dimensions.x < (bb.max.x - bb.min.x) || port_dimensions.y < (bb.max.y - bb.min.y)) && 
        (port_dimensions.y < (bb.max.x - bb.min.x) || port_dimensions.x < (bb.max.y - bb.min.y)) && ![ship isPlayer])
    {
        return NO;
    }
 
    // callback to allow more complex filtering on accept/reject
    JSContext   *context = OOJSAcquireContext();
    jsval       rval = JSVAL_VOID;
    jsval       args[] = { OOJSValueFromNativeObject(context, ship) };
    JSBool accept = YES;
    
    BOOL OK = [[self script] callMethod:OOJSID("acceptLaunchingRequestFrom") inContext:context withArguments:args count:1 result:&rval];
    if (OK)  OK = JS_ValueToBoolean(context, rval, &accept);
    if (!OK)  accept = YES; // default to permreject
    OOJSRelinquishContext(context);
    if (!accept)
    {
        return NO;
    }
 
    return YES;
}   

◆ autoDockShipsInQueue:

- (void) autoDockShipsInQueue: (NSMutableDictionary *) queue

implementation

Provided by category DockEntity(OOPrivate).

Definition at line 1 of file DockEntity.m.

                             :(NSMutableDictionary *)queue
{   
    NSNumber *idObj = nil;
    foreach (idObj, [queue allKeys])
    {
        ShipEntity *ship = [UNIVERSE entityForUniversalID:[idObj unsignedIntValue]];
        if ([ship isShip])
        {
            [self pullInShipIfPermitted:ship];
        }
    }
    
    [queue removeAllObjects];
}

◆ autoDockShipsOnApproach

- (void) autoDockShipsOnApproach

Definition at line 1 of file DockEntity.m.

{
    [self autoDockShipsInQueue:shipsOnApproach];
}

◆ canAcceptShipForDocking:

- (NSString *) canAcceptShipForDocking: (ShipEntity *) ship

Definition at line 1 of file DockEntity.m.

                                     :(ShipEntity *) ship
{
    // First test permanent rejection reasons
    if (!allow_docking)
    {
        return @"DOCK_CLOSED"; // could be temp or perm reject
    }
    BoundingBox bb = [ship totalBoundingBox];
    if ((port_dimensions.x < (bb.max.x - bb.min.x) || port_dimensions.y < (bb.max.y - bb.min.y)) && 
        (port_dimensions.y < (bb.max.x - bb.min.x) || port_dimensions.x < (bb.max.y - bb.min.y)))
    {
        return @"TOO_BIG_TO_DOCK";
    }
 
    // callback to allow more complex filtering on accept/reject
    JSContext   *context = OOJSAcquireContext();
    jsval       rval = JSVAL_VOID;
    jsval       args[] = { OOJSValueFromNativeObject(context, ship) };
    JSBool accept = YES;
    
    BOOL OK = [[self script] callMethod:OOJSID("acceptDockingRequestFrom") inContext:context withArguments:args count:1 result:&rval];
    if (OK)  OK = JS_ValueToBoolean(context, rval, &accept);
    if (!OK)  accept = YES; // default to permreject
    OOJSRelinquishContext(context);
 
    if (!accept)
    {
        return @"TOO_BIG_TO_DOCK";
    }
 
    // Second test temporary rejection reasons
    if (no_docking_while_launching)
    {
        return @"TRY_AGAIN_LATER";
    }
    // if there are pending launches, temporarily don't accept docking requests
    if (allow_launching && [launchQueue count])
    {
        return @"TRY_AGAIN_LATER";
    }
    
    return @"DOCKING_POSSIBLE";
}

◆ clear

- (void) clear

Definition at line 1 of file DockEntity.m.

{
    [launchQueue removeAllObjects];
    [shipsOnApproach removeAllObjects];
}

◆ clearAllIdLocks

- (void) clearAllIdLocks

implementation

Provided by category DockEntity(OOPrivate).

Definition at line 1 of file DockEntity.m.

{
    int i;
    for (i = 1; i < MAX_DOCKING_STAGES; i++)
    {
        DESTROY(id_lock[i]);
    }
}

◆ clearDockingCorridor

- (void) clearDockingCorridor

Definition at line 1 of file DockEntity.m.

{
    // check against all ships
    StationEntity   *station = (StationEntity *)[self parentEntity];
    BOOL            isClear = YES;
    int             ent_count =         UNIVERSE->n_entities;
    Entity          **uni_entities =    UNIVERSE->sortedEntities;   // grab the public sorted list
    Entity          *my_entities[ent_count];
    int i;
    int ship_count = 0;
    
    for (i = 0; i < ent_count; i++)
    {
        if (uni_entities[i]->isShip)
        {
            my_entities[ship_count++] = [uni_entities[i] retain];       //  retained
        }
    }
 
    for (i = 0; i < ship_count; i++)
    {
        ShipEntity  *ship = (ShipEntity*)my_entities[i];
        double      d2 = HPdistance2([station position], [ship position]);
        if ((ship != station)&&(d2 < 25000000)&&([ship status] != STATUS_DOCKED))   // within 5km
        {
            HPVector ppos = [self absolutePositionForSubentity];
            float time_out = -15.00;    // 15 secs
            do
            {
                isClear = YES;
                d2 = HPdistance2(ppos, ship->position);
                if (d2 < 4000000)   // within 2km of the port entrance
                {
                    Quaternion q1 = [station orientation];
                    q1 = quaternion_multiply([self orientation], q1);
                    //
                    Vector v_out = vector_forward_from_quaternion(q1);
                    Vector r_pos = make_vector(ship->position.x - ppos.x, ship->position.y - ppos.y, ship->position.z - ppos.z);
                    if (r_pos.x||r_pos.y||r_pos.z)
                        r_pos = vector_normal(r_pos);
                    else
                        r_pos.z = 1.0;
                    //
                    float vdp = dot_product(v_out, r_pos); //== cos of the angle between r_pos and v_out
                    //
                    if (vdp > 0.86f)
                    {
                        isClear = NO;
                        
                        // okay it's in the way .. give it a wee nudge (0.25s)
                        [ship update: 0.25];
                        time_out += 0.25;
                    }
                    if (time_out > 0)
                    {
                        HPVector v1 = HPvector_forward_from_quaternion(orientation);
                        HPVector spos = ship->position;
                        spos.x += 3000.0 * v1.x;    spos.y += 3000.0 * v1.y;    spos.z += 3000.0 * v1.z; 
                        [ship setPosition:spos]; // move 3km out of the way
                    }
                }
            } while (!isClear);
        }
    }
    
    for (i = 0; i < ship_count; i++)
    {
        [my_entities[i] release];       //released
    }
 
}

◆ clearIdLocks:

- (void) clearIdLocks: (ShipEntity *) ship

implementation

Provided by category DockEntity(OOPrivate).

Definition at line 1 of file DockEntity.m.

                     :(ShipEntity *)ship
{
    int i;
    for (i = 1; i < MAX_DOCKING_STAGES; i++)
    {
        if (ship == nil || ship == [id_lock[i] weakRefUnderlyingObject])
        {
            DESTROY(id_lock[i]);
        }
    }
}

◆ countOfShipsInDockingQueue

- (NSUInteger) countOfShipsInDockingQueue

Definition at line 1 of file DockEntity.m.

{
    return [shipsOnApproach count];
}

◆ countOfShipsInLaunchQueue

- (NSUInteger) countOfShipsInLaunchQueue

Definition at line 1 of file DockEntity.m.

{
    return [launchQueue count];
}

◆ countOfShipsInLaunchQueueWithPrimaryRole:

- (NSUInteger) countOfShipsInLaunchQueueWithPrimaryRole: (NSString *) role

Definition at line 1 of file DockEntity.m.

                                                       :(NSString *)role
{
    NSUInteger count = 0;
    ShipEntity *ship = nil;
    foreach (ship, launchQueue)
    {
        if ([ship hasPrimaryRole:role])  count++;
    }
    return count;
}

◆ dealloc

- (void) dealloc

implementation

Reimplemented from ShipEntity.

Definition at line 1 of file DockEntity.m.

{
    DESTROY(shipsOnApproach);
    DESTROY(launchQueue);
    [self clearIdLocks:nil];
    
    [super dealloc];
}

◆ disallowedDockingCollides

- (BOOL) disallowedDockingCollides

Definition at line 1 of file DockEntity.m.

{
    return disallowed_docking_collides;
}

◆ dockingCorridorIsEmpty

- (BOOL) dockingCorridorIsEmpty

Definition at line 1 of file DockEntity.m.

{
    double unitime = [UNIVERSE getTime];
    
    if (unitime < last_launch_time + STATION_DELAY_BETWEEN_LAUNCHES)
    {
        // leave sufficient pause between launches
        return NO;
    }
    
 
    StationEntity   *station = (StationEntity *)[self parentEntity];
    if ([station playerReservedDock] == self)
    {
        // player probably will not appreciate a ship launch right now
        return NO;
    }
 
    // check against all ships
    BOOL            isEmpty = YES;
    int             ent_count =     UNIVERSE->n_entities;
    Entity          **uni_entities =    UNIVERSE->sortedEntities;   // grab the public sorted list
    Entity          *my_entities[ent_count];
    int i;
    int ship_count = 0;
    
    for (i = 0; i < ent_count; i++)
    {
        //on red alert, launch even if the player is trying block the corridor. Ignore cargopods or other small debris.
        if ([uni_entities[i] isShip] && ([station alertLevel] < STATION_ALERT_LEVEL_RED || ![uni_entities[i] isPlayer]) && [uni_entities[i] mass] > 1000)
        {
            my_entities[ship_count++] = [uni_entities[i] retain];       //  retained
        }
    }
 
    for (i = 0; (i < ship_count)&&(isEmpty); i++)
    {
        ShipEntity* ship = (ShipEntity*)my_entities[i];
        double      d2 = HPdistance2([station position], [ship position]);
        if ((ship != station) && (d2 < 25000000)&&([ship status] != STATUS_DOCKED)) // within 5km
        {
            HPVector ppos = [self absolutePositionForSubentity];
            d2 = HPdistance2(ppos, ship->position);
            if (d2 < 4000000)   // within 2km of the port entrance
            {
                Quaternion q1 = [station orientation];
                q1 = quaternion_multiply([self orientation], q1);
                //
                HPVector v_out = HPvector_forward_from_quaternion(q1);
                HPVector r_pos = make_HPvector(ship->position.x - ppos.x, ship->position.y - ppos.y, ship->position.z - ppos.z);
                if (r_pos.x||r_pos.y||r_pos.z)
                    r_pos = HPvector_normal(r_pos);
                else
                    r_pos.z = 1.0;
                //
                double vdp = HPdot_product(v_out, r_pos); //== cos of the angle between r_pos and v_out
                //
                if (vdp > 0.86)
                {
                    isEmpty = NO;
                    last_launch_time = unitime - STATION_DELAY_BETWEEN_LAUNCHES + STATION_LAUNCH_RETRY_INTERVAL;
                }
            }
        }
    }
    
    for (i = 0; i < ship_count; i++)
    {
        [my_entities[i] release];       //released
    }
 
    return isEmpty;
}

◆ dockingInstructionsForShip:

- (NSDictionary *) dockingInstructionsForShip: (ShipEntity *) ship

Guides a ship into the dock.

Possible results:

null
if no result can be computed or the last control point is reached
Move to station (APPROACH)
if ship is too far away
Move away from station (BACKOFF)
if ship is too close
Move perpendicular to station/dock direction (APPROACH)
if ship is approaching from wrong side of station
Abort (TRY AGAIN LATER)
if something went wrong until here
Hold position (HOLD_POSITION)
if coordinatesStack is empty or approach is not clear
Move to next control point (APPROACH_COORDINATES)
if control point not within collision radius

Algorithm:

If ship is not on approach list and beyond scanner range (25 km?), approach the station
Add ship to approach list
If ship is within distance of 1000 km between station's and ship's collision radius, move away from station
If ship is approaching from behind, move to the side of the station (perpendicular on direction to station and launch vector)
If ship is further away than 12000 km, approach the station

Now the ship is in the vicinity of the station in the correct hemispere. Let's guide them in.

Get the coordinatesStack for this ship (the approach path?). If there is a problem, Ship shall hold position
If next coordinates (control point) not yet within collision radius, move towards that position
Remove control point from stack; get next control point
If next 3 stages of approach are clear, move to next position
otherwise hold position

TODO: Where is the detection that the ship has docked?

TODO: What are the magic number's units? Is it km (kilometers)?

Definition at line 1 of file DockEntity.m.

                                             :(ShipEntity *)ship
{   
    if (ship == nil)  return nil;
    
    OOUniversalID   ship_id = [ship universalID];
    NSNumber        *shipID = [NSNumber numberWithUnsignedShort:ship_id];
    StationEntity   *station = (StationEntity *)[self parentEntity];
 
    HPVector launchVector = HPvector_forward_from_quaternion(quaternion_multiply(orientation, [station orientation]));
    HPVector temp = (fabs(launchVector.x) < 0.8)? make_HPvector(1,0,0) : make_HPvector(0,1,0);
    temp = HPcross_product(launchVector, temp); // 90 deg to launchVector & temp
    HPVector vi = HPcross_product(launchVector, temp);
    HPVector vj = HPcross_product(launchVector, vi);
    HPVector vk = launchVector;
    
    // check if this is a new ship on approach
    //
    if (![shipsOnApproach objectForKey:shipID])
    {
        HPVector    delta = HPvector_subtract([ship position], [self absolutePositionForSubentity]);
        float   ship_distance = HPmagnitude(delta);
 
        if (ship_distance > SCANNER_MAX_RANGE)
        {
            // too far away - don't claim a docking slot by not putting on approachlist for now.
            return OOMakeDockingInstructions(station, [self absolutePositionForSubentity], [ship maxFlightSpeed], 10000, @"APPROACH", nil, NO, -1);
        }
 
        [self addShipToShipsOnApproach: ship];
        
        if (ship_distance < 1000.0 + [station collisionRadius] + ship->collision_radius)    // too close - back off
            return OOMakeDockingInstructions(station, [self absolutePositionForSubentity], [ship maxFlightSpeed], 5000, @"BACK_OFF", nil, NO, -1);
        
        float dot = HPdot_product(launchVector, delta);
        if (dot < 0) // approaching from the wrong side of the station - construct a vector to the side of the station.
        {
            HPVector approachVector = HPcross_product(HPvector_normal(delta), launchVector);
            approachVector = HPcross_product(launchVector, approachVector); // vector, 90 degr rotated from launchVector towards target.
            return OOMakeDockingInstructions(station, OOHPVectorTowards([self absolutePositionForSubentity], approachVector, [station collisionRadius] + 5000) , [ship maxFlightSpeed], 1000, @"APPROACH", nil, NO, -1);
        }
        
        if (ship_distance > 12500.0)
        {
            // long way off - approach more closely
            return OOMakeDockingInstructions(station, [self absolutePositionForSubentity], [ship maxFlightSpeed], 10000, @"APPROACH", nil, NO, -1);
        }
    }
    
    if (![shipsOnApproach objectForKey:shipID])
    {
        // some error has occurred - log it, and send the try-again message
        OOLogERR(@"station.issueDockingInstructions.failed", @"couldn't addShipToShipsOnApproach:%@ in %@, retrying later -- shipsOnApproach:\n%@", ship, self, shipsOnApproach);
        
        return OOMakeDockingInstructions(station, [ship position], 200, 100, @"TRY_AGAIN_LATER", nil, NO, -1);
    }
 
 
    //  shipsOnApproach now has an entry for the ship.
    //
    NSMutableArray* coordinatesStack = [shipsOnApproach objectForKey:shipID];
 
    if ([coordinatesStack count] == 0)
    {
        OOLogERR(@"station.issueDockingInstructions.failed", @" -- coordinatesStack = %@", coordinatesStack);
        
        return OOMakeDockingInstructions(station, [ship position], 0, 100, @"HOLD_POSITION", nil, NO, -1);
    }
    
    // get the docking information from the instructions    
    NSMutableDictionary *nextCoords = (NSMutableDictionary *)[coordinatesStack objectAtIndex:0];
    int docking_stage = [nextCoords oo_intForKey:@"docking_stage"];
    float speedAdvised = [nextCoords oo_floatForKey:@"speed"];
    float rangeAdvised = [nextCoords oo_floatForKey:@"range"];
    
    // calculate world coordinates from relative coordinates
    HPVector rel_coords;
    rel_coords.x = [nextCoords oo_doubleForKey:@"rx"];
    rel_coords.y = [nextCoords oo_doubleForKey:@"ry"];
    rel_coords.z = [nextCoords oo_doubleForKey:@"rz"];
    HPVector coords = [self absolutePositionForSubentity];
    coords.x += rel_coords.x * vi.x + rel_coords.y * vj.x + rel_coords.z * vk.x;
    coords.y += rel_coords.x * vi.y + rel_coords.y * vj.y + rel_coords.z * vk.y;
    coords.z += rel_coords.x * vi.z + rel_coords.y * vj.z + rel_coords.z * vk.z;
    
    // check if the ship is at the control point
    double max_allowed_range = 2.0f * rangeAdvised + ship->collision_radius;    // maximum distance permitted from control point - twice advised range
    HPVector delta = HPvector_subtract(ship->position, coords);
    
    if (HPmagnitude2(delta) > max_allowed_range * max_allowed_range)    // too far from the coordinates - do not remove them from the stack!
    {
        if ((docking_stage == 1) &&(HPmagnitude2(delta) < 1000000.0))   // 1km*1km
            speedAdvised *= 0.5;    // half speed
        
        return OOMakeDockingInstructions(station, coords, speedAdvised, rangeAdvised, @"APPROACH_COORDINATES", nil, NO, docking_stage);
    }
    
    // else, reached the current coordinates okay..
 
    // get the NEXT coordinates
    nextCoords = (NSMutableDictionary *)[coordinatesStack oo_dictionaryAtIndex:1];
    if (nextCoords == nil)
    {
        return nil;
    }
    
    docking_stage = [nextCoords oo_intForKey:@"docking_stage"];
    speedAdvised = [nextCoords oo_floatForKey:@"speed"];
    rangeAdvised = [nextCoords oo_floatForKey:@"range"];
    BOOL match_rotation = [nextCoords oo_boolForKey:@"match_rotation"];
    NSString *comms_message = [nextCoords oo_stringForKey:@"comms_message"];
    
    if (comms_message)
    {
        [station sendExpandedMessage:comms_message toShip:ship];
    }
            
    // calculate world coordinates from relative coordinates
    rel_coords.x = [nextCoords oo_doubleForKey:@"rx"];
    rel_coords.y = [nextCoords oo_doubleForKey:@"ry"];
    rel_coords.z = [nextCoords oo_doubleForKey:@"rz"];
    coords = [self absolutePositionForSubentity];
    coords.x += rel_coords.x * vi.x + rel_coords.y * vj.x + rel_coords.z * vk.x;
    coords.y += rel_coords.x * vi.y + rel_coords.y * vj.y + rel_coords.z * vk.y;
    coords.z += rel_coords.x * vi.z + rel_coords.y * vj.z + rel_coords.z * vk.z;
    
    if([id_lock[docking_stage] weakRefUnderlyingObject] == nil &&
       [id_lock[docking_stage + 1] weakRefUnderlyingObject] == nil &&
       [id_lock[docking_stage + 2] weakRefUnderlyingObject] == nil) // check three stages ahead
    {
        // approach is clear - move to next position
        //
        
        // clear any previously owned docking stages
        [self clearIdLocks:ship];
                
        if (docking_stage > 1)  // don't claim first docking stage
        {
            [id_lock[docking_stage] release];
            id_lock[docking_stage] = [ship weakRetain]; // otherwise - claim this docking stage
        }
        
        //remove the previous stage from the stack
        [coordinatesStack removeObjectAtIndex:0];
        
        return OOMakeDockingInstructions(station, coords, speedAdvised, rangeAdvised, @"APPROACH_COORDINATES", nil, match_rotation, docking_stage);
    }
    
    // else, approach isn't clear - hold position..
    //
    [[ship getAI] message:@"HOLD_POSITION"];
    
    if (![nextCoords objectForKey:@"hold_message_given"])
    {
        // COMM-CHATTER
        [UNIVERSE clearPreviousMessage];
        [self sendExpandedMessage: @"[station-hold-position]" toShip: ship];
        [nextCoords setObject:@"YES" forKey:@"hold_message_given"];
    }
 
    return OOMakeDockingInstructions(station, ship->position, 0, 100, @"HOLD_POSITION", nil, NO, -1);
}

◆ drawImmediate:translucent:

- (void) drawImmediate:	(bool)	immediate
translucent:	(bool)	translucent

implementation

Reimplemented from ShipEntity.

Definition at line 1 of file DockEntity.m.

                      :(bool)immediate translucent:(bool)translucent
{
    if (virtual_dock) // not drawn
    {
        return;
    }
    [super drawImmediate:immediate translucent:translucent];
}

◆ getJSClass:andPrototype:

- (void) getJSClass:	(JSClass **)	outClass
andPrototype:	(JSObject **)	outPrototype

implementation

Reimplemented from ShipEntity.

Provided by category DockEntity(OOJavaScriptExtensions).

Definition at line 256 of file OOJSDock.m.

                  :(JSClass **)outClass andPrototype:(JSObject **)outPrototype
{
    *outClass = &sDockClass;
    *outPrototype = sDockPrototype;
}

◆ initWithKey:definition:

- (id) initWithKey:	(NSString *)	key
definition:	(NSDictionary *)	dict

implementation

Reimplemented from ShipEntity.

Definition at line 1 of file DockEntity.m.

                 :(NSString *)key definition:(NSDictionary *)dict
{
    OOJS_PROFILE_ENTER
    
    self = [super initWithKey:key definition:dict];
    if (self != nil)
    {
        shipsOnApproach = [[NSMutableDictionary alloc] init];
        launchQueue = [[NSMutableArray alloc] init];
        allow_docking = YES;
        disallowed_docking_collides = NO;
        allow_launching = YES;
        virtual_dock = NO;
    }
    
    return self;
    
    OOJS_PROFILE_EXIT
}

◆ isDock

- (BOOL) isDock

implementation

Reimplemented from Entity.

Definition at line 1 of file DockEntity.m.

{
    return YES;
}

◆ isOffCentre

- (BOOL) isOffCentre

Definition at line 1 of file DockEntity.m.

{
    if (fabs(position.x) + fabs(position.y) > 5.0)
    {
        return YES;
    }
    Vector dir = vector_forward_from_quaternion(orientation);
    if (fabs(dir.x) + fabs(dir.y) > 0.1)
    {
        return YES;
    }
    return NO;
}

◆ launchShip:

- (void) launchShip: (ShipEntity *) ship

Definition at line 1 of file DockEntity.m.

                   :(ShipEntity *) ship
{
    if (![ship isShip])  return;
    
    BoundingBox     bb = [ship boundingBox];
    StationEntity   *station = (StationEntity *)[self parentEntity];
    
    HPVector launchPos = [self absolutePositionForSubentity];
    Vector launchVel = [station velocity];
    double launchSpeed = 0.5 * [ship maxFlightSpeed];
    if ([station maxFlightSpeed] > 0 && [station flightSpeed] > 0) // is self a carrier in flight.
    {
        launchSpeed = 0.5 * [ship maxFlightSpeed] * (1.0 + [station flightSpeed]/[station maxFlightSpeed]);
    }
    Quaternion q1 = [station orientation];
    q1 = quaternion_multiply(orientation, q1);
    Vector launchVector = vector_forward_from_quaternion(q1);
    
    // launch orientation
    if ((port_dimensions.x < port_dimensions.y) ^ (bb.max.x - bb.min.x < bb.max.y - bb.min.y))
    {
        quaternion_rotate_about_axis(&q1, launchVector, M_PI*0.5);  // to account for the slot being at 90 degrees to vertical
    }
    [ship setNormalOrientation:q1];
    // launch position
    [ship setPosition:launchPos];
    if([ship pendingEscortCount] > 0) [ship setPendingEscortCount:0]; // Make sure no extra escorts are added after launch. (e.g. for miners etc.)
    if ([ship hasEscorts]) no_docking_while_launching = YES;
    // launch speed
    launchVel = vector_add(launchVel, vector_multiply_scalar(launchVector, launchSpeed));
    launchSpeed = magnitude(launchVel);
    [ship setSpeed:launchSpeed];
    [ship setVelocity:launchVel];
    // launch roll/pitch
    [ship setRoll:[station flightRoll]];
    [ship setPitch:0.0];
    [ship setYaw:0.0];
    [UNIVERSE addEntity:ship];
    [ship setStatus: STATUS_LAUNCHING];
    [ship setDesiredSpeed:launchSpeed]; // must be set after initialising the AI to correct any speed set by AI
    last_launch_time = [UNIVERSE getTime];
    double delay = (port_corridor + 2 * port_dimensions.z)/launchSpeed; // pause until 2 portlengths outside of the station.
    [ship setLaunchDelay:delay];
    [[ship getAI] setNextThinkTime:last_launch_time + delay]; // pause while launching
    
    [ship resetExhaustPlumes];  // resets stuff for tracking/exhausts
    
    [ship doScriptEvent:OOJSID("shipWillLaunchFromStation") withArgument:station];
    [station doScriptEvent:OOJSID("stationLaunchedShip") withArgument:ship andReactToAIMessage: @"STATION_LAUNCHED_SHIP"];
}

◆ noteDockingForShip:

- (void) noteDockingForShip: (ShipEntity *) ship

Definition at line 1 of file DockEntity.m.

                           :(ShipEntity *) ship
{
    // safe to do this for now, as it just clears the ship from the docking queue
    [self abortDockingForShip:ship];
    
    // avoid clashes with outgoing ships
    last_launch_time = [UNIVERSE getTime];
 
}

◆ noteTakingDamage:from:type:

- (void) noteTakingDamage:	(double)	amount
from:	(Entity *)	entity
type:	(OOShipDamageType)	type

implementation

Reimplemented from ShipEntity.

Definition at line 1 of file DockEntity.m.

                         :(double)amount from:(Entity *)entity type:(OOShipDamageType)type
{
    if (virtual_dock) // can't be damaged
    {
        return;
    }
    [super noteTakingDamage:amount from:entity type:type];
}

◆ oo_jsClassName

- (NSString *) oo_jsClassName

implementation

Reimplemented from ShipEntity.

Provided by category DockEntity(OOJavaScriptExtensions).

Definition at line 256 of file OOJSDock.m.

{
    return @"Dock";
}

◆ portUpVectorForShipsBoundingBox:

- (Vector) portUpVectorForShipsBoundingBox: (BoundingBox) bb

Definition at line 1 of file DockEntity.m.

                                          :(BoundingBox)bb
{
    BOOL twist = ((port_dimensions.x < port_dimensions.y) ^ (bb.max.x - bb.min.x < bb.max.y - bb.min.y));
 
    if (!twist)
    {
        return vector_up_from_quaternion(quaternion_multiply(orientation, [[self parentEntity] orientation]));
    }
    else
    {
        return vector_right_from_quaternion(quaternion_multiply(orientation, [[self parentEntity] orientation]));
    }
}

◆ pruneAndCountShipsOnApproach

- (NSUInteger) pruneAndCountShipsOnApproach

Definition at line 1 of file DockEntity.m.

{
    // Remove dead entities.
    // Enumerate over allKeys explicitly because we mutate the dictionary.
    NSNumber *idObj = nil;
    foreach (idObj, [shipsOnApproach allKeys])
    {
        ShipEntity *ship = [UNIVERSE entityForUniversalID:[idObj unsignedIntValue]];
        /* Remove ships from the approach queue if they are dead, or
         * are more than 25.6km from the dock.
         */
        if (ship == nil || HPmagnitude2(HPvector_subtract([ship position],[self absolutePositionForSubentity])) > SCANNER_MAX_RANGE2)
        {
            [shipsOnApproach removeObjectForKey:idObj];
            if (ship != nil) {
                // notify ship if it's alive
                [ship sendAIMessage:@"DOCKING_ABORTED"];
                [ship doScriptEvent:OOJSID("stationWithdrewDockingClearance")];
            }
        }
    }
    
    if ([shipsOnApproach count] == 0)
    {
        if (last_launch_time < [UNIVERSE getTime])
        {
            last_launch_time = [UNIVERSE getTime];
        }
    }
    
    return [shipsOnApproach count];
}

◆ pullInShipIfPermitted:

- (void) pullInShipIfPermitted: (ShipEntity *) ship

implementation

Provided by category DockEntity(OOPrivate).

Definition at line 1 of file DockEntity.m.

                              :(ShipEntity *)ship
{
    // allow_docking: docking permitted and expected
    // disallowed_docking_collides: unauthorised docking does not result in explosion
    if (allow_docking || !disallowed_docking_collides)
    {
        [ship enterDock:(StationEntity*)[self parentEntity]];
    }
}

◆ setAllowsDocking:

- (void) setAllowsDocking: (BOOL) allow

Definition at line 1 of file DockEntity.m.

                         :(BOOL)allowed
{
    if (!allowed && allow_docking) 
    {
        [self abortAllDockings];
    }
    allow_docking = allowed;
}

Referenced by DockSetProperty().

Here is the caller graph for this function:

◆ setAllowsLaunching:

- (void) setAllowsLaunching: (BOOL) allow

Definition at line 1 of file DockEntity.m.

                           :(BOOL)allowed
{
    if (!allowed && allow_launching) 
    {
        [self abortAllLaunches];
    }
    allow_launching = allowed;
}

Referenced by DockSetProperty().

Here is the caller graph for this function:

◆ setDimensionsAndCorridor:docking:ddc:

- (void) setDimensionsAndCorridor:	(BOOL)
docking:	(BOOL)
ddc:	(BOOL)	launching

Definition at line 1 of file DockEntity.m.

                                :(BOOL)docking :(BOOL)ddc :(BOOL)launching
{
    StationEntity *station = (StationEntity*)[self parentEntity];
    if (virtual_dock)
    {
        port_dimensions = [station virtualPortDimensions];
    }
    else
    {
        BoundingBox bb = [self boundingBox];
        port_dimensions = make_vector(bb.max.x - bb.min.x, bb.max.y - bb.min.y, bb.max.z - bb.min.z);
    }
 
    HPVector vk = HPvector_forward_from_quaternion(orientation);
    
    BoundingBox stbb = [station boundingBox];
    HPVector start = position;
    while ((start.x > stbb.min.x)&&(start.x < stbb.max.x) &&
           (start.y > stbb.min.y)&&(start.y < stbb.max.y) &&
           (start.z > stbb.min.z)&&(start.z < stbb.max.z) )
    {
        start = HPvector_add(start, HPvector_multiply_scalar(vk, port_dimensions.z));
    }
    port_corridor = start.z - position.z;
    
    allow_docking = docking;
    disallowed_docking_collides = ddc;
    allow_launching = launching;
}

◆ setDisallowedDockingCollides:

- (void) setDisallowedDockingCollides: (BOOL) ddc

Definition at line 1 of file DockEntity.m.

                                     :(BOOL)ddc
{
    disallowed_docking_collides = ddc;
}

Referenced by DockSetProperty().

Here is the caller graph for this function:

◆ setUpShipFromDictionary:

- (BOOL) setUpShipFromDictionary: (NSDictionary *) dict

implementation

Reimplemented from ShipEntity.

Definition at line 1 of file DockEntity.m.

                                :(NSDictionary *) dict
{
    OOJS_PROFILE_ENTER
    
    isShip = YES;
    isStation = NO;
    
    if (![super setUpShipFromDictionary:dict])  return NO;
    
    return YES;
    
    OOJS_PROFILE_EXIT
}

◆ setVirtual

- (void) setVirtual

Definition at line 1 of file DockEntity.m.

{
    virtual_dock = YES;
}

◆ shipIsInDockingCorridor:

- (BOOL) shipIsInDockingCorridor: (ShipEntity *) ship

Definition at line 1 of file DockEntity.m.

                                :(ShipEntity *)ship
{
    if (![ship isShip])  return NO;
    if ([ship isPlayer] && [ship status] == STATUS_DEAD)  return NO;
 
    BOOL allow_docking_thisship = allow_docking || !disallowed_docking_collides;
    // ships can physically dock here, and this routine is mainly for
    // collision detection, but will never be directed here by traffic
    // control, if allow_docking is false but d_d_c is also false
    
    StationEntity *station = (StationEntity *)[self parentEntity];
    if ([station status] == STATUS_DEAD)
    {
        return NO;
    }
    
    Quaternion q0 = quaternion_multiply(orientation, [station orientation]);
    Vector vi = vector_right_from_quaternion(q0);
    Vector vj = vector_up_from_quaternion(q0);
    Vector vk = vector_forward_from_quaternion(q0);
    
    HPVector port_pos = [self absolutePositionForSubentity];
    
    BoundingBox shipbb = [ship boundingBox];
    BoundingBox arbb = [ship findBoundingBoxRelativeToPosition: port_pos InVectors: vi : vj : vk];
    
    // port dimensions..
    GLfloat ww = port_dimensions.x;
    GLfloat hh = port_dimensions.y;
    GLfloat dd = port_dimensions.z;
 
    BOOL rotatedPort = (ww >= hh) ? NO : YES;
    BOOL rotatedShip = ((shipbb.max.x - shipbb.min.x) >= (shipbb.max.y - shipbb.min.y)) ? NO : YES;
    BOOL rotationsMatch = (rotatedShip == rotatedPort);
    if (rotationsMatch)
    {
        // the ship and port are both bigger in x than y
        while (shipbb.max.x - shipbb.min.x > ww * 0.90) ww *= 1.25;
        while (shipbb.max.y - shipbb.min.y > hh * 0.90) hh *= 1.25;
    }
    else
    {
        // the ship and port have different x/y biggerness
        while (shipbb.max.y - shipbb.min.y > ww * 0.90) ww *= 1.25;
        while (shipbb.max.x - shipbb.min.x > hh * 0.90) hh *= 1.25;
    }
    
    ww *= 0.5;
    hh *= 0.5;
 
#ifndef NDEBUG
    if ([ship isPlayer] && (gDebugFlags & DEBUG_DOCKING))
    {
        BOOL            inLane;
        float           range;
        unsigned        laneFlags = 0;
        
        if (arbb.max.x < ww)   laneFlags |= 1;
        if (arbb.min.x > -ww)  laneFlags |= 2;
        if (arbb.max.y < hh)   laneFlags |= 4;
        if (arbb.min.y > -hh)  laneFlags |= 8;
        inLane = laneFlags == 0xF;
        range = 0.90 * arbb.max.z + 0.10 * arbb.min.z;
        
        OOLog(@"docking.debug", @"Normalised port dimensions are %g x %g x %g.  Player bounding box is at %@-%@ -- %s (%X), range: %g",
            ww * 2.0, hh * 2.0, dd,
            VectorDescription(arbb.min), VectorDescription(arbb.max),
            inLane ? "in lane" : "out of lane", laneFlags,
            range);
    }
#endif
 
    if ((arbb.max.x < ww * 3.0)&&(arbb.min.x > -ww * 3.0)&&(arbb.max.y < hh * 3.0)&&(arbb.min.y > -hh * 3.0))
    {
        if ([station requiresDockingClearance] && [ship isPlayer] && [ship status] != STATUS_LAUNCHING && [ship status] != STATUS_AUTOPILOT_ENGAGED && [PLAYER getDockingClearanceStatus] < DOCKING_CLEARANCE_STATUS_GRANTED)
        {
            if ((0.90 * arbb.max.z + 0.10 * arbb.min.z < 3000) && (dot_product(vk,[ship forwardVector]) < -0.9))
            {
                // player is in docking corridor and facing dock
                // and within 3km
                [UNIVERSE addMessage:DESC(@"oolite-station-docking-requires-clearance") forCount:3];
            }
        }
    }
    
    if (arbb.max.z < -dd)
    {
        return NO;
    }
    
    if ((arbb.max.x < ww)&&(arbb.min.x > -ww)&&(arbb.max.y < hh)&&(arbb.min.y > -hh))
    {
        if ([ship status] != STATUS_LAUNCHING && !allow_docking_thisship)
        { // launch-only dock: will collide!
            if (arbb.min.z < dd)
            {
                [ship takeScrapeDamage: 5 * [UNIVERSE getTimeDelta]*[ship flightSpeed] from:station];
                // and bounce
                HPVector rel = HPvector_subtract([ship position],port_pos);
                rel = HPvector_multiply_scalar(HPvector_normal(rel),[ship flightSpeed]*0.4);
                [ship adjustVelocity:HPVectorToVector(rel)];
            }
 
            if (arbb.max.z < 0.0)
            { // give some warning before exploding...
                return NO;
            }
        }
 
        // in lane
        if (0.90 * arbb.max.z + 0.10 * arbb.min.z < 0.0)    // we're 90% in docking position!
        {
            [self pullInShipIfPermitted:ship];
        }
        return YES;
    }
    
    if ([ship status] == STATUS_LAUNCHING)
    {
        return YES;
    }
    
    // if close enough (within 50%) correct and add damage
    //
    GLfloat safety = 1.0+(50.0/100.0);
 
    if ((arbb.min.x > -safety * ww)&&(arbb.max.x < safety * ww)&&(arbb.min.y > -safety * hh)&&(arbb.max.y < safety * hh))
    {
        if (arbb.min.z < 0.0)   // got our nose inside
        {
 
            if ((arbb.min.x < -ww && arbb.max.x > ww) || (arbb.min.y < -hh && arbb.max.y > hh))
            {
                /* No matter how much safety margin there is, if the
                 * ship is going off opposite edges of the dock at
                 * once, that's a fatal collision */
                return NO;
            }
 
            GLfloat correction_factor = -arbb.min.z / (arbb.max.z - arbb.min.z);    // proportion of ship inside
        
            // damage the ship according to velocity - don't send collision messages to AIs to avoid problems.
            [ship takeScrapeDamage: 5 * [UNIVERSE getTimeDelta]*[ship flightSpeed] from:station];
            [station doScriptEvent:OOJSID("shipCollided") withArgument:ship]; // no COLLISION message to station AI, carriers would move away!
            [ship doScriptEvent:OOJSID("shipCollided") withArgument:station]; // no COLLISION message to ship AI, dockingAI.plist would abort.
            
            Vector delta;
            delta.x = 0.5f * (arbb.max.x + arbb.min.x) * correction_factor;
            delta.y = 0.5f * (arbb.max.y + arbb.min.y) * correction_factor;
            
            if (arbb.max.x < ww && arbb.min.x > -ww)
            {
                // x is okay - no need to correct
                delta.x = 0.0f;
            }
            if (arbb.max.y > hh && arbb.min.y > -hh)
            {
                // y is okay - no need to correct
                delta.y = 0.0f;
            }
                
            // adjust the ship back to the center of the port
            HPVector pos = [ship position];
            pos.x -= delta.y * vj.x + delta.x * vi.x;
            pos.y -= delta.y * vj.y + delta.x * vi.y;
            pos.z -= delta.y * vj.z + delta.x * vi.z;
            [ship setPosition:pos];
        }
        
        // if far enough in - dock
        if (0.90f * arbb.max.z + 0.10f * arbb.min.z < 0.0f)
        {
            [self pullInShipIfPermitted:ship];
        }
        
        return YES; // okay NOW we're in the docking corridor!
    }
    
    return NO;
}

◆ shipIsInDockingQueue:

- (BOOL) shipIsInDockingQueue: (ShipEntity *) ship

Definition at line 1 of file DockEntity.m.

                             :(ShipEntity *)ship
{
    if (![ship isShip])  return NO;
    if ([ship isPlayer] && [ship status] == STATUS_DEAD)  return NO;
    
    OOUniversalID   ship_id = [ship universalID];
    NSNumber        *shipID = [NSNumber numberWithUnsignedShort:ship_id];
    
    if ([shipsOnApproach objectForKey:shipID])
    {
        return YES;
    }
    // player docking manually
    if ([ship isPlayer] && [[self owner] playerReservedDock] == self)
    {
        return YES;
    }
    return NO;
}

Referenced by DockEntity(OOJavaScriptExtensions)::getJSClass:andPrototype:.

Here is the caller graph for this function:

◆ takeEnergyDamage:from:becauseOf:weaponIdentifier:

- (void) takeEnergyDamage:	(double)	amount
from:	(Entity *)	ent
becauseOf:	(Entity *)	other
weaponIdentifier:	(NSString *)	weaponIdentifier

implementation

Reimplemented from ShipEntity.

Definition at line 1 of file DockEntity.m.

                         :(double)amount from:(Entity *)ent becauseOf:(Entity *)other weaponIdentifier:(NSString *)weaponIdentifier
{
    if (virtual_dock) // can't be damaged
    {
        return;
    }
    [super takeEnergyDamage:amount from:ent becauseOf:other weaponIdentifier:weaponIdentifier];
}

◆ update:

- (void) update: (OOTimeDelta) delta_t

implementation

Reimplemented from ShipEntity.

Definition at line 1 of file DockEntity.m.

               :(OOTimeDelta) delta_t
{
    [super update:delta_t];
    
    if (([launchQueue count] > 0)&&([shipsOnApproach count] == 0)&&[self dockingCorridorIsEmpty])
    {
        ShipEntity *se=(ShipEntity *)[launchQueue objectAtIndex:0];
        // check to make sure ship has not been destroyed in queue by script
        if ([se status] == STATUS_DOCKED)
        {
            [self launchShip:se];
        }
        [launchQueue removeObjectAtIndex:0];
    }
    if (([launchQueue count] == 0) && no_docking_while_launching)
    {
        no_docking_while_launching = NO;    // launching complete
    }
    
}

Member Data Documentation

◆ allow_docking

- (BOOL) allow_docking

private

Definition at line 46 of file DockEntity.h.

◆ allow_launching

- (BOOL) allow_launching

private

Definition at line 45 of file DockEntity.h.

◆ disallowed_docking_collides

- (BOOL) disallowed_docking_collides

private

Definition at line 47 of file DockEntity.h.

◆ id_lock

- (ShipEntity* id_lock[MAX_DOCKING_STAGES])

private

Definition at line 39 of file DockEntity.h.

◆ last_launch_time

- (double) last_launch_time

private

Definition at line 36 of file DockEntity.h.

◆ launchQueue

- (NSMutableArray*) launchQueue

private

Definition at line 35 of file DockEntity.h.

◆ no_docking_while_launching

- (BOOL) no_docking_while_launching

private

Definition at line 44 of file DockEntity.h.

◆ port_corridor

- (double) port_corridor

private

Definition at line 42 of file DockEntity.h.

◆ port_dimensions

- (Vector) port_dimensions

private

Definition at line 41 of file DockEntity.h.

◆ shipsOnApproach

- (NSMutableDictionary*) shipsOnApproach

private

Definition at line 34 of file DockEntity.h.

◆ virtual_dock

- (BOOL) virtual_dock

private

Definition at line 48 of file DockEntity.h.

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

src/Core/Entities/DockEntity.h
src/Core/Entities/DockEntity.m

Instance Methods

Private Attributes

Additional Inherited Members

Detailed Description

Method Documentation

◆ abortAllDockings

◆ abortAllLaunches

◆ abortDockingForShip:

◆ addShipToLaunchQueue:withPriority:

◆ addShipToShipsOnApproach:

◆ allowsDocking

◆ allowsLaunching

◆ allowsLaunchingOf:

◆ autoDockShipsInQueue:

◆ autoDockShipsOnApproach

◆ canAcceptShipForDocking:

◆ clear

◆ clearAllIdLocks

◆ clearDockingCorridor

◆ clearIdLocks:

◆ countOfShipsInDockingQueue

◆ countOfShipsInLaunchQueue

◆ countOfShipsInLaunchQueueWithPrimaryRole:

◆ dealloc

◆ disallowedDockingCollides

◆ dockingCorridorIsEmpty

◆ dockingInstructionsForShip:

Possible results:

Algorithm:

◆ drawImmediate:translucent:

◆ getJSClass:andPrototype:

◆ initWithKey:definition:

◆ isDock

◆ isOffCentre

◆ launchShip:

◆ noteDockingForShip:

◆ noteTakingDamage:from:type:

◆ oo_jsClassName

◆ portUpVectorForShipsBoundingBox:

◆ pruneAndCountShipsOnApproach

◆ pullInShipIfPermitted:

◆ setAllowsDocking:

◆ setAllowsLaunching:

◆ setDimensionsAndCorridor:docking:ddc:

◆ setDisallowedDockingCollides:

◆ setUpShipFromDictionary:

◆ setVirtual

◆ shipIsInDockingCorridor:

◆ shipIsInDockingQueue:

◆ takeEnergyDamage:from:becauseOf:weaponIdentifier:

◆ update:

Member Data Documentation

◆ allow_docking

◆ allow_launching

◆ disallowed_docking_collides

◆ id_lock

◆ last_launch_time

◆ launchQueue

◆ no_docking_while_launching

◆ port_corridor

◆ port_dimensions

◆ shipsOnApproach

◆ virtual_dock