DockEntity(OOPrivate) Category Reference

Instance Methods
(void)	- clearIdLocks:
(void)	- clearAllIdLocks
(void)	- autoDockShipsInQueue:
(void)	- addShipToShipsOnApproach:
(void)	- pullInShipIfPermitted:

Detailed Description

Definition at line 49 of file DockEntity.m.

Method Documentation

addShipToShipsOnApproach:

- (void) addShipToShipsOnApproach:

(ShipEntity *)

ship

Extends class DockEntity.

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];
    }
}

autoDockShipsInQueue:

- (void) autoDockShipsInQueue:

(NSMutableDictionary *)

queue

Extends class DockEntity.

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];
}

clearAllIdLocks

- (void) clearAllIdLocks

Extends class DockEntity.

Definition at line 1 of file DockEntity.m.

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

clearIdLocks:

- (void) clearIdLocks:

(ShipEntity *)

ship

Extends class DockEntity.

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]);
        }
    }
}

pullInShipIfPermitted:

- (void) pullInShipIfPermitted:

(ShipEntity *)

ship

Extends class DockEntity.

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]];
    }
}

---

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

• src/Core/Entities/DockEntity.m