ShipEntity(AI) Category Reference

#include <ShipEntityAI.h>

Instance Methods
(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]

Detailed Description

Definition at line 32 of file ShipEntityAI.h.

Method Documentation

broadcastDistressMessage

- (void) broadcastDistressMessage

Definition at line 1 of file ShipEntityAI.m.

{
    /*-- Locates all the stations, bounty hunters and police ships in range and tells them that you are under attack --*/
    [self broadcastDistressMessageWithDumping:YES];
}   

broadcastDistressMessageWithDumping:

- (void) broadcastDistressMessageWithDumping:

(BOOL)

dumpCargo

Definition at line 1 of file ShipEntityAI.m.

                                            :(BOOL)dumpCargo
{
    [self checkScannerIgnoringUnpowered];
    DESTROY(_foundTarget);
    
    ShipEntity  *aggressor_ship = (ShipEntity*)[self primaryAggressor];
    if (aggressor_ship == nil)  return;
    
    // don't send too many distress messages at once, space them out semi-randomly
    if (messageTime > 2.0 * randf())  return;
    
    NSString    *distress_message = nil;
    BOOL        is_buoy = (scanClass == CLASS_BUOY);
    if (is_buoy)  distress_message = @"[buoy-distress-call]";
    else  distress_message = @"[distress-call]";
    
    unsigned i;
    for (i = 0; i < n_scanned_ships; i++)
    {
        ShipEntity* ship = scanned_ships[i];
 
    // dump cargo if energy is low
        if (dumpCargo && !is_buoy && [self primaryAggressor] == ship && energy < 0.375 * maxEnergy)
        {
            [self ejectCargo];
            [self performFlee];
        }
        
        // tell it! (only plist AIs send comms here; JS AIs are
        // expected to handle their own)
        if (ship->isPlayer && ![self hasNewAI])
        {
            [ship doScriptEvent:OOJSID("distressMessageReceived") withArgument:aggressor_ship andArgument:self];
 
            if (!is_buoy && [self primaryAggressor] == ship && energy < 0.375 * maxEnergy)
            {
                [self sendExpandedMessage:@"[beg-for-mercy]" toShip:ship];
            }
            else if ([self bounty] == 0)
            {
                // only send distress message to player if plausibly sending
                // one more generally
                [self sendExpandedMessage:distress_message toShip:ship];
            }
            
            // reset the thanked_ship_id
            DESTROY(_thankedShip);
        }
        else if ([self bounty] == 0 && [ship crew]) // Only clean ships can have their distress calls accepted
        {
            [ship doScriptEvent:OOJSID("distressMessageReceived") withArgument:aggressor_ship andArgument:self];
            
            // we only can send distressMessages to ships that are known to have a "ACCEPT_DISTRESS_CALL" reaction
            // in their AI, or they might react wrong on the added found_target.
 
            // ship must have a plist AI for this next bit. JS AIs
            // should already have done something sensible on
            // distressMessageReceived
            if (![self hasNewAI])
            {
                // FIXME: this test only works with core AIs
                if (ship->isStation || [ship hasPrimaryRole:@"police"] || [ship hasPrimaryRole:@"hunter"])
                {
                    [ship acceptDistressMessageFrom:self];
                }
            }
        }
    }
}

enterPlayerWormhole

- (void) enterPlayerWormhole

Definition at line 1 of file ShipEntityAI.m.

{
    [self enterWormhole:[PLAYER wormhole] replacing:NO];
}

enterTargetWormhole

- (void) enterTargetWormhole

Definition at line 1 of file ShipEntityAI.m.

{
    WormholeEntity *whole = nil;
    ShipEntity      *targEnt = [self primaryTarget];
    double found_d2 = scannerRange * scannerRange;
    
    if (targEnt && (HPdistance2(position, [targEnt position]) < found_d2))
    {
        if ([targEnt isWormhole])
            whole = (WormholeEntity *)targEnt;
        else if ([targEnt isPlayer])
            whole = [PLAYER wormhole];
    }
 
    if (!whole)
    {
        // locate nearest wormhole
        int             ent_count =     UNIVERSE->n_entities;
        Entity**        uni_entities =  UNIVERSE->sortedEntities;   // grab the public sorted list
        WormholeEntity* wormholes[ent_count];
        int i;
        int wh_count = 0;
        for (i = 0; i < ent_count; i++)
            if (uni_entities[i]->isWormhole)
                wormholes[wh_count++] = [(WormholeEntity *)uni_entities[i] retain];
        //
        //double found_d2 = scannerRange * scannerRange;
        for (i = 0; i < wh_count ; i++)
        {
            WormholeEntity *wh = wormholes[i];
            double d2 = HPdistance2(position, wh->position);
            if (d2 < found_d2)
            {
                whole = wh;
                found_d2 = d2;
            }
            [wh release];
        }
    }
    
    [self enterWormhole:whole replacing:NO];
}

groupAttackTarget

- (void) groupAttackTarget

Definition at line 1 of file ShipEntityAI.m.

{
    ShipEntity          *target = nil, *ship = nil;
 
    target = [self primaryTarget];
    
    if (target == nil) return;
    
    if ([self group] == nil)        // ship is alone!
    {
        [self setFoundTarget:target];
        [shipAI reactToMessage:@"GROUP_ATTACK_TARGET" context:@"groupAttackTarget"];
        [self doScriptEvent:OOJSID("helpRequestReceived") withArgument:self andArgument:target];
        return;
    }
    
    foreach (ship, [[self group] mutationSafeEnumerator])
    {
        [ship setFoundTarget:target];
        [ship reactToAIMessage:@"GROUP_ATTACK_TARGET" context:@"groupAttackTarget"];
        [ship doScriptEvent:OOJSID("helpRequestReceived") withArgument:self andArgument:target];
 
        if ([ship escortGroup] != [ship group] && [[ship escortGroup] count] > 1) // Ship has a seperate escort group.
        {
            ShipEntity      *escort = nil;
            NSArray         *escortMembers = [[ship escortGroup] memberArrayExcludingLeader];
            foreach (escort, escortMembers)
            {
                [escort setFoundTarget:target];
                [escort reactToAIMessage:@"GROUP_ATTACK_TARGET" context:@"groupAttackTarget"];
                [escort doScriptEvent:OOJSID("helpRequestReceived") withArgument:self andArgument:target];
            }
        }
    }
}

performAttack

- (void) performAttack

Definition at line 1 of file ShipEntityAI.m.

{
    if (behaviour != BEHAVIOUR_EVASIVE_ACTION)
    {
        behaviour = BEHAVIOUR_ATTACK_TARGET;
        desired_range = 1250 * randf() + 750; // 750 til 2000
        frustration = 0.0;  
    }
}

performBuoyTumble

- (void) performBuoyTumble

implementation

Definition at line 1 of file ShipEntityAI.m.

{
    stick_roll = 0.10;
    stick_pitch = 0.15;
    behaviour = BEHAVIOUR_TUMBLE;
    frustration = 0.0;
}

performCollect

- (void) performCollect

Definition at line 1 of file ShipEntityAI.m.

{
    behaviour = BEHAVIOUR_COLLECT_TARGET;
    frustration = 0.0;
}

performEscort

- (void) performEscort

Definition at line 1 of file ShipEntityAI.m.

{
    if(behaviour != BEHAVIOUR_FORMATION_FORM_UP) 
    {
        behaviour = BEHAVIOUR_FORMATION_FORM_UP;
        frustration = 0.0; // behavior changed, reset frustration.
    }
}

performFaceDestination

- (void) performFaceDestination

Definition at line 1 of file ShipEntityAI.m.

{
    behaviour = BEHAVIOUR_FACE_DESTINATION;
    frustration = 0.0;
}

performFlee

- (void) performFlee

Definition at line 1 of file ShipEntityAI.m.

{
    if (behaviour != BEHAVIOUR_FLEE_EVASIVE_ACTION)
    {
        behaviour = BEHAVIOUR_FLEE_TARGET;
        [self setEvasiveJink:400.0];
        frustration = 0.0;
        if (accuracy > COMBAT_AI_ISNT_AWFUL)
        {
            // alert! they've got us in their sights! react!!
            if ([self approachAspectToPrimaryTarget] > 0.9995)
            {
                behaviour = randf() < 0.15 ? BEHAVIOUR_EVASIVE_ACTION : BEHAVIOUR_FLEE_EVASIVE_ACTION;
            }
        }
    }
}

performFlyToRangeFromDestination

- (void) performFlyToRangeFromDestination

Definition at line 1 of file ShipEntityAI.m.

{
    behaviour = BEHAVIOUR_FLY_RANGE_FROM_DESTINATION;
    frustration = 0.0;
}

performHold

- (void) performHold

Definition at line 1 of file ShipEntityAI.m.

{
    desired_speed = 0.0;
    behaviour = BEHAVIOUR_TRACK_TARGET;
    frustration = 0.0;
}

performHyperSpaceToSpecificSystem:

- (BOOL) performHyperSpaceToSpecificSystem:

(OOSystemID)

systemID

Definition at line 1 of file ShipEntityAI.m.

                                          :(OOSystemID)systemID
{
    return [self performHyperSpaceExitReplace:NO toSystem:systemID];
}

performIdle

- (void) performIdle

Definition at line 1 of file ShipEntityAI.m.

{
    behaviour = BEHAVIOUR_IDLE;
    frustration = 0.0;
}

performIntercept

- (void) performIntercept

Definition at line 1 of file ShipEntityAI.m.

{
    behaviour = BEHAVIOUR_INTERCEPT_TARGET;
    frustration = 0.0;
}

performLandOnPlanet

- (void) performLandOnPlanet

Definition at line 1 of file ShipEntityAI.m.

{
    OOPlanetEntity  *nearest = [self findNearestPlanet];
    if (isNearPlanetSurface)
    {
        _destination = [nearest position];
        behaviour = BEHAVIOUR_LAND_ON_PLANET;
        planetForLanding = [nearest universalID];
    }
    else
    {
        behaviour = BEHAVIOUR_IDLE;
        [shipAI message:@"NO_PLANET_NEARBY"];
    }
    
    frustration = 0.0;
}

performMining

- (void) performMining

Definition at line 1 of file ShipEntityAI.m.

{
    Entity *target = [self primaryTarget];
    // mining is not seen as hostile behaviour, so ensure it is only used against rocks.
    if (target &&  [target scanClass] == CLASS_ROCK)
    {
        behaviour = BEHAVIOUR_ATTACK_MINING_TARGET;
        frustration = 0.0;
    }
    else
    {   
        [self noteLostTargetAndGoIdle];
    }
}

performScriptedAI

- (void) performScriptedAI

Definition at line 1 of file ShipEntityAI.m.

{
    behaviour = BEHAVIOUR_SCRIPTED_AI;
    frustration = 0.0;
}

performScriptedAttackAI

- (void) performScriptedAttackAI

Definition at line 1 of file ShipEntityAI.m.

{
    behaviour = BEHAVIOUR_SCRIPTED_ATTACK_AI;
    frustration = 0.0;
}

performStop

- (void) performStop

Definition at line 1 of file ShipEntityAI.m.

{
    behaviour = BEHAVIOUR_STOP_STILL;
    desired_speed = 0.0;
    frustration = 0.0;
}

performTumble

- (void) performTumble

Definition at line 1 of file ShipEntityAI.m.

{
    stick_roll = max_flight_roll*2.0*(randf() - 0.5);
    stick_pitch = max_flight_pitch*2.0*(randf() - 0.5);
    behaviour = BEHAVIOUR_TUMBLE;
    frustration = 0.0;
}

recallDockingInstructions

- (void) recallDockingInstructions

Definition at line 1 of file ShipEntityAI.m.

{
    if (dockingInstructions != nil)
    {
        _destination = [dockingInstructions oo_hpvectorForKey:@"destination"];
        desired_speed = fmin([dockingInstructions oo_floatForKey:@"speed"], maxFlightSpeed);
        desired_range = [dockingInstructions oo_floatForKey:@"range"];
        if ([dockingInstructions objectForKey:@"station"])
        {
            StationEntity *targetStation = [[dockingInstructions objectForKey:@"station"] weakRefUnderlyingObject];
            if (targetStation != nil)
            {
                [self addTarget:targetStation];
                [self setTargetStation:targetStation];
            }
            else 
            {
                [self removeTarget:[self primaryTarget]];
            }
        }
        docking_match_rotation = [dockingInstructions oo_boolForKey:@"match_rotation"];
    }
}

requestDockingCoordinates

- (void) requestDockingCoordinates

Definition at line 1 of file ShipEntityAI.m.

{
    /*- requests coordinates from the target station
     if the target station can't be found
     then use the nearest it can find (which may be a rock hermit) -*/
    
    StationEntity   *station =  nil;
    Entity          *targStation = nil;
    NSString        *message = nil;
    double      distanceToStation2 = 0.0;
    
    targStation = [self targetStation];
    if ([targStation isStation])
    {
        station = (StationEntity*)targStation;
    }
    else
    {
        station = [UNIVERSE nearestShipMatchingPredicate:IsStationPredicate
                                               parameter:nil
                                        relativeToEntity:self];
    }
    
    distanceToStation2 = HPdistance2([station position], [self position]);
    
    // Player check for being inside the aegis already exists in PlayerEntityControls. We just
    // check here that distance to station is less than 2.5 times scanner range to avoid problems with
    // NPC ships getting stuck with a dockingAI while just outside the aegis - Nikos 20090630, as proposed by Eric
    // On very busy systems (> 50 docking ships) docking ships can be sent to a hold position outside the range, 
    // so also test for presence of dockingInstructions. - Eric 20091130
    if (station != nil && (distanceToStation2 < SCANNER_MAX_RANGE2 * 6.25 || dockingInstructions != nil))
    {
        // remember the instructions
        [dockingInstructions release];
        dockingInstructions = [[station dockingInstructionsForShip:self] retain];
        if (dockingInstructions != nil)
        {
            [self recallDockingInstructions];
            
            message = [dockingInstructions objectForKey:@"ai_message"];
            if (message != nil)  [shipAI message:message];
            message = [dockingInstructions objectForKey:@"comms_message"];
            if (message != nil)  [station sendExpandedMessage:message toShip:self];
        }
    }
    else
    {
        DESTROY(dockingInstructions);
    }
    
    if (dockingInstructions == nil)
    {
        [shipAI message:@"NO_STATION_FOUND"];
    }
}

scanForHostiles

- (void) scanForHostiles

Definition at line 1 of file ShipEntityAI.m.

{
    /*-- Locates all the ships in range targeting the receiver and chooses the nearest --*/
    DESTROY(_foundTarget);
    
    [self checkScanner];
    unsigned i;
    GLfloat found_d2 = scannerRange * scannerRange;
    for (i = 0; i < n_scanned_ships ; i++)
    {
        ShipEntity *thing = scanned_ships[i];
        GLfloat d2 = distance2_scanned_ships[i];
        if ((d2 < found_d2) 
            && ([thing isThargoid] || (([thing primaryTarget] == self) && [thing hasHostileTarget]) || [thing isDefenseTarget:self])
            && ![thing isCloaked])
        {
            [self setFoundTarget:thing];
            found_d2 = d2;
        }
    }
    
    [self checkFoundTarget];
}

scanForNearestIncomingMissile

- (void) scanForNearestIncomingMissile

Definition at line 1 of file ShipEntityAI.m.

{
    BinaryOperationPredicateParameter param =
    {
        HasScanClassPredicate, [NSNumber numberWithInt:CLASS_MISSILE],
        IsHostileAgainstTargetPredicate, self
    };
    [self scanForNearestShipWithPredicate:ANDPredicate parameter:&param];
}

setAIScript:

- (void) setAIScript:

(NSString *)

aiString

Definition at line 1 of file ShipEntityAI.m.

                    :(NSString *)aiString
{
    NSMutableDictionary     *properties = nil;
    
    properties = [NSMutableDictionary dictionary];
    [properties setObject:self forKey:@"ship"];
    
    [aiScript autorelease];
    aiScript = [OOScript jsAIScriptFromFileNamed:aiString properties:properties];
    if (aiScript == nil)
    {
        OOLog(@"ai.load.failed.unknownAI",@"Unable to load JS AI %@ for ship %@ (%@ for role %@)",aiString,self,[self shipDataKey],[self primaryRole]);
        aiScript = [OOScript jsAIScriptFromFileNamed:@"oolite-nullAI.js" properties:properties];
    }
    else
    {
        aiScriptWakeTime = 0;
        haveStartedJSAI = NO;
    }
    [aiScript retain];
}

setAITo:

- (void) setAITo:

(NSString *)

aiString

Definition at line 1 of file ShipEntityAI.m.

                :(NSString *)aiString
{
    // don't try to load real AIs if the game hasn't started yet
    if (![PLAYER scriptsLoaded])
    {
        aiString = @"oolite-nullAI.js";
    }
    if ([aiString hasSuffix:@".plist"])
    {
        [[self getAI] setStateMachine:aiString withJSScript:@"oolite-nullAI.js"];
        [self setAIScript:@"oolite-nullAI.js"];
    }
    else if ([aiString hasSuffix:@".js"])
    {
        [[self getAI] setStateMachine:@"nullAI.plist" withJSScript:aiString];
        [self setAIScript:aiString];
    }
    else
    {
        NSString *path = [ResourceManager pathForFileNamed:[aiString stringByAppendingString:@".js"] inFolder:@"AIs"];
        if (path == nil) // no js, use plist
        {
            [self setAITo:[aiString stringByAppendingString:@".plist"]];
        }
        else
        {
            [self setAITo:[aiString stringByAppendingString:@".js"]];
        }
    }
}

suggestEscortTo:

- (BOOL) suggestEscortTo:

(ShipEntity *)

mother

Definition at line 1 of file ShipEntityAI.m.

                        :(ShipEntity *)mother
{
    if (mother)
    {
#ifndef NDEBUG
        if (reportAIMessages)
        {
            OOLog(@"ai.suggestEscort", @"DEBUG: %@ suggests escorting %@", self, mother);
        }
#endif
        
        if ([mother acceptAsEscort:self])
        {
            // copy legal status across
            if (([mother legalStatus] > 0)&&(bounty <= 0))
            {
                int extra = 1 | (ranrot_rand() & 15);
//              [mother setBounty: [mother legalStatus] + extra withReason:kOOLegalStatusReasonAssistingOffender];
                [self markAsOffender:extra withReason:kOOLegalStatusReasonAssistingOffender];
                //              bounty += extra;    // obviously we're dodgier than we thought!
            }
            
            [self setOwner:mother];
            [self setGroup:[mother escortGroup]];
            [shipAI message:@"ESCORTING"];
            return YES;
        }
        
#ifndef NDEBUG
        if (reportAIMessages)
        {
            OOLog(@"ai.suggestEscort.refused", @"DEBUG: %@ refused by %@", self, mother);
        }
#endif
        
    }
    [self setOwner:self];
    [shipAI message:@"NOT_ESCORTING"];
    [self doScriptEvent:OOJSID("escortRejected") withArgument:mother];
    return NO;
}

switchAITo:

- (void) switchAITo:

(NSString *)

aiString

Definition at line 1 of file ShipEntityAI.m.

                   :(NSString *)aiString
{
    [self setAITo:aiString];
    [[self getAI] clearStack];
}

wormholeEntireGroup

- (void) wormholeEntireGroup

Definition at line 1 of file ShipEntityAI.m.

{
    [self wormholeGroup];
    [self wormholeEscorts];
}

wormholeEscorts

- (void) wormholeEscorts

Definition at line 1 of file ShipEntityAI.m.

{
    ShipEntity          *ship = nil;
    NSString            *context = nil;
    WormholeEntity      *whole = nil;
    
    whole = [self primaryTarget];
    if (![whole isWormhole])  return;
    
#ifndef NDEBUG
    context = [NSString stringWithFormat:@"%@ wormholeEscorts", [self shortDescription]];
#endif
    
    foreach (ship, [self escortEnumerator])
    {
        [ship addTarget:whole];
        [ship reactToAIMessage:@"ENTER WORMHOLE" context:context];
        [ship doScriptEvent:OOJSID("wormholeSuggested") withArgument:whole];
    }
    
    // We now have no escorts..
 
    [_escortGroup release];
    _escortGroup = nil;
 
}

---

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

• src/Core/Entities/ShipEntityAI.h
• src/Core/Entities/ShipEntityAI.m