#include <OOShipRegistry.h>

Inheritance diagram for OOShipRegistry:

Collaboration diagram for OOShipRegistry:

Instance Methods
(NSDictionary *)	- shipInfoForKey:

(void)	- setShipInfoForKey:with:

(NSDictionary *)	- effectInfoForKey:

(NSDictionary *)	- shipyardInfoForKey:

(OOProbabilitySet *)	- probabilitySetForRole:

(NSArray *)	- demoShipKeys

(NSArray *)	- playerShipKeys

(id)	- init `[implementation]`

(void)	- dealloc `[implementation]`

(NSArray *)	- shipKeys

(NSArray *)	- shipRoles

(NSArray *)	- shipKeysWithRole:

(NSString *)	- randomShipKeyForRole:

(void)	- loadShipData `[implementation]`

(void)	- loadDemoShipConditions `[implementation]`

(void)	- loadDemoShips `[implementation]`

(void)	- loadCachedRoleProbabilitySets `[implementation]`

(void)	- buildRoleProbabilitySets `[implementation]`

(BOOL)	- applyLikeShips:withKey: `[implementation]`

(BOOL)	- loadAndMergeShipyard: `[implementation]`

(BOOL)	- stripPrivateKeys: `[implementation]`

(BOOL)	- makeShipEntriesMutable: `[implementation]`

(BOOL)	- loadAndApplyShipDataOverrides: `[implementation]`

(BOOL)	- canonicalizeAndTagSubentities: `[implementation]`

(BOOL)	- removeUnusableEntries:shipMode: `[implementation]`

(BOOL)	- sanitizeConditions: `[implementation]`

(NSMutableDictionary *)	- mergeShip:withParent: `[implementation]`

(void)	- mergeShipRoles:forShipKey:intoProbabilityMap: `[implementation]`

(NSDictionary *)	- canonicalizeSubentityDeclaration:forShip:shipData:fatalError: `[implementation]`

(NSDictionary *)	- translateOldStyleSubentityDeclaration:forShip:shipData:fatalError: `[implementation]`

(NSDictionary *)	- translateOldStyleFlasherDeclaration:forShip:fatalError: `[implementation]`

(NSDictionary *)	- translateOldStandardBasicSubentityDeclaration:forShip:shipData:fatalError: `[implementation]`

(NSDictionary *)	- validateNewStyleSubentityDeclaration:forShip:fatalError: `[implementation]`

(NSDictionary *)	- validateNewStyleFlasherDeclaration:forShip:fatalError: `[implementation]`

(NSDictionary *)	- validateNewStyleStandardSubentityDeclaration:forShip:fatalError: `[implementation]`

(BOOL)	- shipIsBallTurretForKey:inShipData: `[implementation]`

(id)	- copyWithZone: `[implementation]`

(id)	- retain `[implementation]`

(NSUInteger)	- retainCount `[implementation]`

(void)	- release `[implementation]`

(id)	- autorelease `[implementation]`

Class Methods
(OOShipRegistry *)	+ sharedRegistry

(void)	+ reload

(id)	+ allocWithZone: `[implementation]`

Private Attributes
NSDictionary *	_shipData

NSDictionary *	_effectData

NSArray *	_demoShips

NSArray *	_playerShips

NSDictionary *	_probabilitySets

Detailed Description

Definition at line 35 of file OOShipRegistry.h.

Method Documentation

◆ allocWithZone:

+ (id) allocWithZone: (NSZone *) inZone

implementation

Provided by category OOShipRegistry(Singleton).

Definition at line 1820 of file OOShipRegistry.m.

                    :(NSZone *)inZone
{
    if (sSingleton == nil)
    {
        OOLog(@"shipData.load.begin", @"%@", @"Loading ship data.");
        sSingleton = [super allocWithZone:inZone];
        return sSingleton;
    }
    return nil;
}

◆ applyLikeShips:withKey:

- (BOOL) applyLikeShips:		(NSMutableDictionary *)	ioData
withKey:		(NSString *)	likeKey

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                       :(NSMutableDictionary *)ioData withKey:(NSString *)likeKey
{
    NSMutableSet            *remainingLikeShips = nil;
    NSEnumerator            *enumerator = nil;
    NSString                *key = nil;
    NSString                *parentKey = nil;
    NSDictionary            *shipEntry = nil;
    NSDictionary            *parentEntry = nil;
    NSUInteger              count, lastCount;
    NSMutableArray          *reportedBadShips = nil;
    
    // Build set of ships with like_ship references
    remainingLikeShips = [NSMutableSet set];
    for (enumerator = [ioData keyEnumerator]; (key = [enumerator nextObject]); )
    {
        shipEntry = [ioData objectForKey:key];
        if ([shipEntry oo_stringForKey:likeKey] != nil)
        {
            [remainingLikeShips addObject:key];
        }
    }
    
    count = lastCount = [remainingLikeShips count];
    while (count != 0)
    {
        for (enumerator = [[[remainingLikeShips copy] autorelease] objectEnumerator]; (key = [enumerator nextObject]); )
        {
            // Look up like_ship entry
            shipEntry = [ioData objectForKey:key];
            parentKey = [shipEntry objectForKey:likeKey];
            if (![remainingLikeShips containsObject:parentKey])
            {
                // If parent is fully resolved, we can resolve this child.
                parentEntry = [ioData objectForKey:parentKey];
                shipEntry = [self mergeShip:shipEntry withParent:parentEntry];
                if (shipEntry != nil)
                {
                    [remainingLikeShips removeObject:key];
                    [ioData setObject:shipEntry forKey:key];
                }
            }
        }
        
        count = [remainingLikeShips count];
        if (count == lastCount)
        {
            /*  Fail: we couldn't resolve all like_ship entries.
                Remove unresolved entries, building a list of the ones that
                don't have is_external_dependency set.
            */
            reportedBadShips = [NSMutableArray array];
            for (enumerator = [remainingLikeShips objectEnumerator]; (key = [enumerator nextObject]); )
            {
                if (![[ioData oo_dictionaryForKey:key] oo_boolForKey:@"is_external_dependency"])
                {
                    [reportedBadShips addObject:key];
                }
                [ioData removeObjectForKey:key];
            }
            
            if ([reportedBadShips count] != 0)
            {
                [reportedBadShips sortUsingSelector:@selector(caseInsensitiveCompare:)];
                OOLogERR(@"shipData.merge.failed", @"one or more shipdata.plist entries have %@ references that cannot be resolved: %@", likeKey, [reportedBadShips componentsJoinedByString:@", "]); // FIXME: distinguish shipdata and effectdata
                OOStandardsError(@"Likely missing a dependency in a manifest.plist");
            }
            break;
        }
        lastCount = count;
    }
    
    return YES;
}

◆ autorelease

- (id) autorelease

implementation

Provided by category OOShipRegistry(Singleton).

Definition at line 1820 of file OOShipRegistry.m.

{
    return self;
}

◆ buildRoleProbabilitySets

- (void) buildRoleProbabilitySets

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

{
    NSMutableDictionary     *probabilitySets = nil;
    NSEnumerator            *shipEnum = nil;
    NSString                *shipKey = nil;
    NSDictionary            *shipEntry = nil;
    NSString                *roles = nil;
    NSEnumerator            *roleEnum = nil;
    NSString                *role = nil;
    OOProbabilitySet        *pset = nil;
    NSMutableDictionary     *cacheEntry = nil;
    
    probabilitySets = [NSMutableDictionary dictionary];
    
    // Build role sets
    for (shipEnum = [_shipData keyEnumerator]; (shipKey = [shipEnum nextObject]); )
    {
        shipEntry = [_shipData objectForKey:shipKey];
        roles = [shipEntry oo_stringForKey:@"roles"];
        [self mergeShipRoles:roles forShipKey:shipKey intoProbabilityMap:probabilitySets];
    }
    
    // Convert role sets to immutable form, and build cache entry.
    // Note: we iterate over a copy of the keys to avoid mutating while iterating.
    cacheEntry = [NSMutableDictionary dictionaryWithCapacity:[probabilitySets count]];
    for (roleEnum = [[probabilitySets allKeys] objectEnumerator]; (role = [roleEnum nextObject]); )
    {
        pset = [probabilitySets objectForKey:role];
        pset = [[pset copy] autorelease];
        [probabilitySets setObject:pset forKey:role];
        [cacheEntry setObject:[pset propertyListRepresentation] forKey:role];
    }
    
    _probabilitySets = [probabilitySets copy];
    [[OOCacheManager sharedCache] setObject:cacheEntry forKey:kRoleWeightsCacheKey inCache:kShipRegistryCacheName];
}

◆ canonicalizeAndTagSubentities:

- (BOOL) canonicalizeAndTagSubentities: (NSMutableDictionary *) ioData

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                      :(NSMutableDictionary *)ioData
{
    NSEnumerator            *shipKeyEnum = nil;
    NSString                *shipKey = nil;
    NSMutableDictionary     *shipEntry = nil;
    NSArray                 *subentityDeclarations = nil;
    NSEnumerator            *subentityEnum = nil;
    id                      subentityDecl = nil;
    NSDictionary            *subentityDict = nil;
    NSString                *subentityKey = nil;
    NSMutableDictionary     *subentityShipEntry = nil;
    NSMutableSet            *badSubentities = nil;
    NSString                *badSubentitiesList = nil;
    NSMutableArray          *okSubentities = nil;
    BOOL                    remove, fatal;
    
    // Convert all subentity declarations to dictionaries and add
    // _oo_is_subentity=YES to all entries used as subentities.
    
    // Iterate over all ships. (Iterates over a copy of keys since it mutates the dictionary.)
    for (shipKeyEnum = [[ioData allKeys] objectEnumerator]; (shipKey = [shipKeyEnum nextObject]); )
    {
        shipEntry = [ioData objectForKey:shipKey];
        remove = NO;
        badSubentities = nil;
        
        // Iterate over each subentity declaration of each ship
        subentityDeclarations = [shipEntry oo_arrayForKey:@"subentities"];
        if (subentityDeclarations != nil)
        {
            okSubentities = [NSMutableArray arrayWithCapacity:[subentityDeclarations count]];
            for (subentityEnum = [subentityDeclarations objectEnumerator]; (subentityDecl = [subentityEnum nextObject]); )
            {
                subentityDict = [self canonicalizeSubentityDeclaration:subentityDecl forShip:shipKey shipData:ioData fatalError:&fatal];
                
                // If entry is broken, we need to kill this ship.
                if (fatal)
                {
                    OOStandardsError(@"Bad subentity definition found");
                    remove = YES;
                }
                else if (subentityDict != nil)
                {
                    [okSubentities addObject:subentityDict];
                    
                    // Tag subentities.
                    if (![[subentityDict oo_stringForKey:@"type"] isEqualToString:@"flasher"])
                    {
                        subentityKey = [subentityDict oo_stringForKey:@"subentity_key"];
                        subentityShipEntry = [ioData objectForKey:subentityKey];
                        if (subentityKey == nil || subentityShipEntry == nil)
                        {
                            // Oops, reference to non-existent subent.
                            if (badSubentities == nil)  badSubentities = [NSMutableSet set];
                            [badSubentities addObject:subentityKey];
                        }
                        else
                        {
                            // Subent exists, add _oo_is_subentity so roles aren't required.
                            [subentityShipEntry oo_setBool:YES forKey:@"_oo_is_subentity"];
                        }
                    }
                }
            }
            
            // Set updated subentity list.
            if ([okSubentities count] != 0)
            {
                [shipEntry setObject:okSubentities forKey:@"subentities"];
            }
            else
            {
                [shipEntry removeObjectForKey:@"subentities"];
            }
            
            if (badSubentities != nil)
            {
                if (![shipEntry oo_boolForKey:@"is_external_dependency"])
                {
                    badSubentitiesList = [[[badSubentities allObjects] sortedArrayUsingSelector:@selector(caseInsensitiveCompare:)] componentsJoinedByString:@", "];
                    OOLogERR(@"shipData.load.error", @"the shipdata.plist entry \"%@\" has unresolved subentit%@ %@.", shipKey, ([badSubentities count] == 1) ? @"y" : @"ies", badSubentitiesList);
                    OOStandardsError(@"Bad subentity definition found");
                }
                remove = YES;
            }
            
            if (remove)
            {
                // Removal is deferred to avoid bogus "entry doesn't exist" errors.
                [shipEntry oo_setBool:YES forKey:@"_oo_deferred_remove"];
            }
        }
    }
    
    return YES;
}

◆ canonicalizeSubentityDeclaration:forShip:shipData:fatalError:

- (NSDictionary *) canonicalizeSubentityDeclaration:	(id)	declaration
forShip:	(NSString *)	shipKey
shipData:	(NSDictionary *)	shipData
fatalError:	(BOOL *)	outFatalError

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                                   :(id)declaration
                                            forShip:(NSString *)shipKey
                                           shipData:(NSDictionary *)shipData
                                         fatalError:(BOOL *)outFatalError
{
    NSDictionary            *result = nil;
    
    assert(outFatalError != NULL);
    *outFatalError = NO;
    
    if ([declaration isKindOfClass:[NSString class]])
    {
        // Update old-style string-based declaration.
        OOStandardsDeprecated([NSString stringWithFormat:@"Old style sub-entity declarations are deprecated in %@",shipKey]);
        if (!OOEnforceStandards())
        {
            result = [self translateOldStyleSubentityDeclaration:declaration
                                                         forShip:shipKey
                                                        shipData:shipData
                                                      fatalError:outFatalError];
        }
        if (result != nil)
        {
            // Ensure internal translation made sense, and clean up a bit.
            result = [self validateNewStyleSubentityDeclaration:result
                                                        forShip:shipKey
                                                     fatalError:outFatalError];
        }
    }
    else if ([declaration isKindOfClass:[NSDictionary class]])
    {
        // Validate dictionary-based declaration.
        result = [self validateNewStyleSubentityDeclaration:declaration
                                                    forShip:shipKey
                                                 fatalError:outFatalError];
    }
    else
    {
        OOLogERR(@"shipData.load.error.badSubentity", @"subentity declaration for ship %@ should be string or dictionary, found %@.", shipKey, [declaration class]);
        *outFatalError = YES;
    }
    
    // For frangible ships, bad subentities are non-fatal.
    if (*outFatalError && [[shipData oo_dictionaryForKey:shipKey] oo_boolForKey:@"frangible"])  *outFatalError = NO;
    
    return result;
}

◆ copyWithZone:

- (id) copyWithZone: (NSZone *) inZone

implementation

Provided by category OOShipRegistry(Singleton).

Definition at line 1820 of file OOShipRegistry.m.

                   :(NSZone *)inZone
{
    return self;
}

◆ dealloc

- (void) dealloc

implementation

Definition at line 1820 of file OOShipRegistry.m.

{
    [_shipData release];
    [_demoShips release];
    [_playerShips release];
    [_probabilitySets release];
    
    [super dealloc];
}

◆ demoShipKeys

- (NSArray *) demoShipKeys

Definition at line 1820 of file OOShipRegistry.m.

{
    // with condition scripts in use, can't cache this value
    [self loadDemoShips];
 
    return [[_demoShips copy] autorelease]; 
}

◆ effectInfoForKey:

- (NSDictionary *) effectInfoForKey: (NSString *) key

Definition at line 1820 of file OOShipRegistry.m.

                                   :(NSString *)key
{
    return [_effectData objectForKey:key];
}

◆ init

- (id) init

implementation

Definition at line 1820 of file OOShipRegistry.m.

{
    if ((self = [super init]))
    {
        NSAutoreleasePool       *pool = [[NSAutoreleasePool alloc] init];
        OOCacheManager          *cache = [OOCacheManager sharedCache];
        
        _shipData = [[cache objectForKey:kShipDataCacheKey inCache:kShipRegistryCacheName] retain];
        _playerShips = [[cache objectForKey:kPlayerShipsCacheKey inCache:kShipRegistryCacheName] retain];
        _effectData = [[cache objectForKey:kVisualEffectDataCacheKey inCache:kVisualEffectRegistryCacheName] retain];
        if ([_shipData count] == 0) // Don't accept nil or empty
        {
            [self loadShipData];
            if ([_shipData count] == 0)
            {
                [NSException raise:@"OOShipRegistryLoadFailure" format:@"Could not load any ship data."];
            }
            if ([_playerShips count] == 0)
            {
                [NSException raise:@"OOShipRegistryLoadFailure" format:@"Could not load any player ships."];
            }
        }
        
        [self loadDemoShipConditions];
        [self loadDemoShips]; // testing only
        if ([_demoShips count] == 0)
        {
            [NSException raise:@"OOShipRegistryLoadFailure" format:@"Could not load or synthesize any demo ships."];
        }
        
        [self loadCachedRoleProbabilitySets];
        if (_probabilitySets == nil)
        {
            [self buildRoleProbabilitySets];
            if ([_probabilitySets count] == 0)
            {
                [NSException raise:@"OOShipRegistryLoadFailure" format:@"Could not load or synthesize role probability sets."];
            }
        }
        
        [pool release];
    }
    return self;
}

◆ loadAndApplyShipDataOverrides:

- (BOOL) loadAndApplyShipDataOverrides: (NSMutableDictionary *) ioData

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                      :(NSMutableDictionary *)ioData
{
    NSEnumerator            *shipKeyEnum = nil;
    NSString                *shipKey = nil;
    NSMutableDictionary     *shipEntry = nil;
    NSDictionary            *overrides = nil;
    NSDictionary            *overridesEntry = nil;
    
    overrides = [ResourceManager dictionaryFromFilesNamed:@"shipdata-overrides.plist"
                                                 inFolder:@"Config"
                                                mergeMode:MERGE_SMART
                                                    cache:NO];
    
    for (shipKeyEnum = [overrides keyEnumerator]; (shipKey = [shipKeyEnum nextObject]); )
    {
        shipEntry = [ioData objectForKey:shipKey];
        if (shipEntry != nil)
        {
            overridesEntry = [overrides objectForKey:shipKey];
            if (![overridesEntry isKindOfClass:[NSDictionary class]])
            {
                OOLogERR(@"shipData.load.error", @"the shipdata-overrides.plist entry \"%@\" is not a dictionary.", shipKey);
            }
            else
            {
                [shipEntry addEntriesFromDictionary:overridesEntry];
            }
        }
    }
    
    return YES;
}

◆ loadAndMergeShipyard:

- (BOOL) loadAndMergeShipyard: (NSMutableDictionary *) ioData

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                             :(NSMutableDictionary *)ioData
{
    NSEnumerator            *shipKeyEnum = nil;
    NSString                *shipKey = nil;
    NSMutableDictionary     *shipEntry = nil;
    NSDictionary            *shipyard = nil;
    NSDictionary            *shipyardOverrides = nil;
    NSDictionary            *shipyardEntry = nil;
    NSDictionary            *shipyardOverridesEntry = nil;
    NSMutableArray          *playerShips = nil;
    
    // Strip out any shipyard stuff in shipdata (there shouldn't be any).
    for (shipKeyEnum = [ioData keyEnumerator]; (shipKey = [shipKeyEnum nextObject]); )
    {
        shipEntry = [ioData objectForKey:shipKey];
        if ([shipEntry objectForKey:@"_oo_shipyard"] != nil)
        {
            [shipEntry removeObjectForKey:@"_oo_shipyard"];
        }
    }
    
    shipyard = [ResourceManager dictionaryFromFilesNamed:@"shipyard.plist"
                                                inFolder:@"Config"
                                               mergeMode:MERGE_BASIC
                                                   cache:NO];
    shipyardOverrides = [ResourceManager dictionaryFromFilesNamed:@"shipyard-overrides.plist"
                                                         inFolder:@"Config"
                                                        mergeMode:MERGE_SMART
                                                            cache:NO];
    
    playerShips = [NSMutableArray arrayWithCapacity:[shipyard count]];
    
    // Insert merged shipyard and shipyardOverrides entries.
    for (shipKeyEnum = [shipyard keyEnumerator]; (shipKey = [shipKeyEnum nextObject]); )
    {
        shipEntry = [ioData objectForKey:shipKey];
        if (shipEntry != nil)
        {
            shipyardEntry = [shipyard objectForKey:shipKey];
            shipyardOverridesEntry = [shipyardOverrides objectForKey:shipKey];
            shipyardEntry = [shipyardEntry dictionaryByAddingEntriesFromDictionary:shipyardOverridesEntry];
            
            [shipEntry setObject:shipyardEntry forKey:@"_oo_shipyard"];
            
            [playerShips addObject:shipKey];
        }
        else
        {
            OOLogWARN(@"shipData.load.shipyard.unknown", @"the shipyard.plist entry \"%@\" does not have a corresponding shipdata.plist entry, ignoring.", shipKey);
        }
    }
    
    _playerShips = [playerShips copy];
    [[OOCacheManager sharedCache] setObject:_playerShips forKey:kPlayerShipsCacheKey inCache:kShipRegistryCacheName];
    
    return YES;
}

◆ loadCachedRoleProbabilitySets

- (void) loadCachedRoleProbabilitySets

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

{
    NSDictionary            *cachedSets = nil;
    NSMutableDictionary     *restoredSets = nil;
    NSEnumerator            *roleEnum = nil;
    NSString                *role = nil;
    
    cachedSets = [[OOCacheManager sharedCache] objectForKey:kRoleWeightsCacheKey inCache:kShipRegistryCacheName];
    if (cachedSets == nil)  return;
    
    restoredSets = [NSMutableDictionary dictionaryWithCapacity:[cachedSets count]];
    for (roleEnum = [cachedSets keyEnumerator]; (role = [roleEnum nextObject]); )
    {
        [restoredSets setObject:[OOProbabilitySet probabilitySetWithPropertyListRepresentation:[cachedSets objectForKey:role]] forKey:role];
    }
    
    _probabilitySets = [restoredSets copy];
}

◆ loadDemoShipConditions

- (void) loadDemoShipConditions

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

{
    NSMutableArray *conditionScripts = [[NSMutableArray alloc] init];
    NSEnumerator            *enumerator = nil;
    NSDictionary            *key = nil;
    NSArray                 *initialDemoShips = nil;
 
    initialDemoShips = [ResourceManager arrayFromFilesNamed:@"shiplibrary.plist"
                                                   inFolder:@"Config"
                                                   andMerge:YES
                                                      cache:NO];
 
    for (enumerator = [initialDemoShips objectEnumerator]; (key = [enumerator nextObject]); )
    {
        NSString *conditions = [key oo_stringForKey:kOODemoShipConditions defaultValue:nil];
        if (conditions != nil)
        {
            [conditionScripts addObject:conditions];
        }
    }
 
    [[OOCacheManager sharedCache] setObject:conditionScripts forKey:@"demoship conditions" inCache:@"condition scripts"];
    [conditionScripts release];
}

◆ loadDemoShips

- (void) loadDemoShips

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

{
    NSEnumerator            *enumerator = nil;
    NSDictionary            *key = nil;
    NSArray                 *initialDemoShips = nil;
    NSMutableArray          *demoShips = nil;
    
    DESTROY(_demoShips);
    
    initialDemoShips = [ResourceManager arrayFromFilesNamed:@"shiplibrary.plist"
                                                   inFolder:@"Config"
                                                   andMerge:YES
                                                      cache:NO];
    demoShips = [NSMutableArray arrayWithArray:initialDemoShips];
    
    // Note: iterate over initialDemoShips to avoid mutating the collection being enu,erated.
    for (enumerator = [initialDemoShips objectEnumerator]; (key = [enumerator nextObject]); )
    {
        NSString *shipKey = [key oo_stringForKey:kOODemoShipKey];
        if (![key isKindOfClass:[NSDictionary class]] || [self shipInfoForKey:shipKey] == nil)
        {
            [demoShips removeObject:key];
        }
        else 
        {
            NSString *conditions = [key oo_stringForKey:kOODemoShipConditions defaultValue:nil];
            if (conditions != nil)
            {
                if ([PLAYER status] == STATUS_START_GAME)
                {
                    // conditions always false here
                    [demoShips removeObject:key];
                }
                else
                {
                    OOJSScript *condScript = [UNIVERSE getConditionScript:conditions];
                    if (condScript != nil) // should always be non-nil, but just in case
                    {
                        JSContext           *context = OOJSAcquireContext();
                        BOOL OK;
                        JSBool allow_use;
                        jsval result;
                        jsval args[] = { OOJSValueFromNativeObject(context, shipKey) };
                        
                        OK = [condScript callMethod:OOJSID("allowShowLibraryShip")
                                          inContext:context
                                      withArguments:args count:sizeof args / sizeof *args
                                             result:&result];
 
                        if (OK) OK = JS_ValueToBoolean(context, result, &allow_use);
            
                        OOJSRelinquishContext(context);
                        if (OK && !allow_use)
                        {
                            /* if the script exists, the function exists, the function
                             * returns a bool, and that bool is false, hide the
                             * ship. Otherwise allow it as default */
                            [demoShips removeObject:key];
                        }
                    }
                }
            }
        }
    }
    
    if ([demoShips count] == 0)
    {
        NSString *shipKey = nil;
        if ([self shipInfoForKey:kDefaultDemoShip] != nil) 
        {
            shipKey = kDefaultDemoShip;
        }
        else
        {
            shipKey = [[_shipData allKeys] objectAtIndex:0];
        }
        [demoShips addObject:[NSDictionary dictionaryWithObject:shipKey forKey:kOODemoShipKey]];
    }
    
    // now separate out the demoships by class, and add some extra keys
    NSMutableDictionary *demoList = [NSMutableDictionary dictionaryWithCapacity:8];
    NSMutableArray *demoClass = nil;
    foreach(key, demoShips)
    {
        NSString *class = [key oo_stringForKey:kOODemoShipClass defaultValue:@"ship"];
        if ([OOShipLibraryCategoryPlural(class) length] == 0)
        {
            OOLog(@"shipdata.load.warning",@"Unexpected class '%@' in shiplibrary.plist for '%@'",class,[key oo_stringForKey:kOODemoShipKey]);
            class = @"ship";
        }
        demoClass = [demoList objectForKey:class];
        if (demoClass == nil)
        {
            [demoList setObject:[NSMutableArray array] forKey:class];
            demoClass = [demoList objectForKey:class];
        }
        NSMutableDictionary *demoEntry = [NSMutableDictionary dictionaryWithDictionary:key];
        // add "name" object to dictionary from ship definition
        [demoEntry setObject:[[self shipInfoForKey:[demoEntry oo_stringForKey:@"ship"]] oo_stringForKey:kOODemoShipName] forKey:kOODemoShipName];
        // set "class" object to standard ship if not otherwise set
        if (![[demoEntry oo_stringForKey:kOODemoShipClass defaultValue:nil] isEqualToString:class])
        {
            [demoEntry setObject:class forKey:kOODemoShipClass];
        }
        [demoClass addObject:demoEntry];
    }
    // sort each ship list by name
    NSString *demoClassName = nil;
    foreach(demoClassName, demoList)
    {
        [[demoList objectForKey:demoClassName] sortUsingFunction:SortDemoShipsByName context:NULL];
    }
 
    // and then sort the ship list list by class name
    _demoShips = [[[demoList allValues] sortedArrayUsingFunction:SortDemoCategoriesByName context:NULL] retain];
}

◆ loadShipData

- (void) loadShipData

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

{
    NSMutableDictionary     *result = nil;
    
    [_shipData release];
    _shipData = nil;
    [_playerShips release];
    _playerShips = nil;
    
    // Load shipdata.plist.
    result = [[[ResourceManager dictionaryFromFilesNamed:@"shipdata.plist"
                                                inFolder:@"Config"
                                               mergeMode:MERGE_BASIC
                                                   cache:NO] mutableCopy] autorelease];
    if (result == nil)  return;
    
    DumpStringAddrs(result, @"shipdata.plist");
    
    // Make each entry mutable to simplify later stages. Also removes any entries that aren't dictionaries.
    if (![self makeShipEntriesMutable:result])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished initial cleanup...");
    
    // Apply patches.
    if (![self loadAndApplyShipDataOverrides:result])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished applying patches...");
    
    // Strip private keys (anything starting with _oo_).
    if (![self stripPrivateKeys:result])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished stripping private keys...");
    
    // Resolve like_ship entries.
    if (![self applyLikeShips:result withKey:@"like_ship"])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished resolving like_ships...");
    
    // Clean up subentity declarations and tag subentities so they won't be pruned.
    if (![self canonicalizeAndTagSubentities:result])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished cleaning up subentities...");
    
    // Clean out templates and invalid entries.
    if (![self removeUnusableEntries:result shipMode:YES])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished removing invalid entries...");
    
    // Add shipyard entries into shipdata entries.
    if (![self loadAndMergeShipyard:result])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished adding shipyard entries...");
    
    // Sanitize conditions.
    if (![self sanitizeConditions:result])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished validating data...");
    
#if PRELOAD
    // Preload and cache meshes.
    if (![self preloadShipMeshes:result])  return;
    OOLog(@"shipData.load.progress", @"%@", @"Finished loading meshes...");
#endif
    
    _shipData = OODeepCopy(result);
    [[OOCacheManager sharedCache] setObject:_shipData forKey:kShipDataCacheKey inCache:kShipRegistryCacheName];
    
    OOLog(@"shipData.load.done", @"%@", @"Ship data loaded.");
 
    [_effectData release];
    _effectData = nil;
 
    result = [[[ResourceManager dictionaryFromFilesNamed:@"effectdata.plist"
                                                inFolder:@"Config"
                                               mergeMode:MERGE_BASIC
                                                   cache:NO] mutableCopy] autorelease];
    if (result == nil)  return;
 
    // Make each entry mutable to simplify later stages. Also removes any entries that aren't dictionaries.
    if (![self makeShipEntriesMutable:result])  return;
    OOLog(@"effectData.load.progress", @"%@", @"Finished initial cleanup...");
 
    // Strip private keys (anything starting with _oo_).
    if (![self stripPrivateKeys:result])  return;
    OOLog(@"effectData.load.progress", @"%@", @"Finished stripping private keys...");
    
    // Resolve like_effect entries.
    if (![self applyLikeShips:result withKey:@"like_effect"])  return;
    OOLog(@"effectData.load.progress", @"%@", @"Finished resolving like_effects...");
    
    // Clean up subentity declarations and tag subentities so they won't be pruned.
    if (![self canonicalizeAndTagSubentities:result])  return;
    OOLog(@"effectData.load.progress", @"%@", @"Finished cleaning up subentities...");
    
    // Clean out templates and invalid entries.
    if (![self removeUnusableEntries:result shipMode:NO])  return;
    OOLog(@"effectData.load.progress", @"%@", @"Finished removing invalid entries...");
    
    _effectData = OODeepCopy(result);
    [[OOCacheManager sharedCache] setObject:_effectData forKey:kVisualEffectDataCacheKey inCache:kVisualEffectRegistryCacheName];
    
    OOLog(@"effectData.load.done", @"%@", @"Effect data loaded.");
}

◆ makeShipEntriesMutable:

- (BOOL) makeShipEntriesMutable: (NSMutableDictionary *) ioData

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                               :(NSMutableDictionary *)ioData
{
    NSEnumerator            *shipKeyEnum = nil;
    NSString                *shipKey = nil;
    NSDictionary            *shipEntry = nil;
    
    for (shipKeyEnum = [[ioData allKeys] objectEnumerator]; (shipKey = [shipKeyEnum nextObject]); )
    {
        shipEntry = [ioData objectForKey:shipKey];
        if (![shipEntry isKindOfClass:[NSDictionary class]])
        {
            OOLogERR(@"shipData.load.badEntry", @"the shipdata.plist entry \"%@\" is not a dictionary.", shipKey);
            [ioData removeObjectForKey:shipKey];
        }
        else
        {
            shipEntry = [shipEntry mutableCopy];
            
            [ioData setObject:shipEntry forKey:shipKey];
            [shipEntry release];
        }
    }
    
    return YES;
}

◆ mergeShip:withParent:

- (NSMutableDictionary *) mergeShip:		(NSDictionary *)	child
withParent:		(NSDictionary *)	parent

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                   :(NSDictionary *)child withParent:(NSDictionary *)parent
{
    NSMutableDictionary *result = [[parent mutableCopy] autorelease];
    if (result == nil)  return nil;
    
    [result addEntriesFromDictionary:child];
    [result removeObjectForKey:@"like_ship"];
    
    // Certain properties cannot be inherited.
    if ([child oo_stringForKey:@"display_name"] == nil)  [result removeObjectForKey:@"display_name"];
    if ([child oo_stringForKey:@"is_template"] == nil)  [result removeObjectForKey:@"is_template"];
    
    // Since both 'scanClass' and 'scan_class' are accepted as valid keys for the scanClass property,
    // we may end up with conflicting scanClass and scan_class keys from like_ship relationships getting
    // merged in the result dictionary. We want to always have the child overriding the parent setting
    // and we do that by determining which of the two keys belongs to the child dictionary and removing
    // the other one from the result - Nikos 20100512
    if ([result oo_stringForKey:@"scan_class"] != nil && [result oo_stringForKey:@"scanClass"] != nil)
    {
        if ([child oo_stringForKey:@"scanClass"] != nil)
            [result removeObjectForKey:@"scan_class"];
        else
            [result removeObjectForKey:@"scanClass"];
    }
    // TODO: all normalised/non-normalised value name pairs need to be catered for. - Kaks 2010-05-13
    if ([result oo_stringForKey:@"escort_role"] != nil && [result oo_stringForKey:@"escort-role"] != nil)
    {
        if ([child oo_stringForKey:@"escort-role"] != nil)
            [result removeObjectForKey:@"escort_role"];
        else
            [result removeObjectForKey:@"escort-role"];
    }
    if ([result oo_stringForKey:@"escort_ship"] != nil && [result oo_stringForKey:@"escort-ship"] != nil)
    {
        if ([child oo_stringForKey:@"escort-ship"] != nil)
            [result removeObjectForKey:@"escort_ship"];
        else
            [result removeObjectForKey:@"escort-ship"];
    }
    if ([result oo_stringForKey:@"is_carrier"] != nil && [result oo_stringForKey:@"isCarrier"] != nil)
    {
        if ([child oo_stringForKey:@"isCarrier"] != nil)
            [result removeObjectForKey:@"is_carrier"];
        else
            [result removeObjectForKey:@"isCarrier"];
    }
    if ([result oo_stringForKey:@"has_shipyard"] != nil && [result oo_stringForKey:@"hasShipyard"] != nil)
    {
        if ([child oo_stringForKey:@"hasShipyard"] != nil)
            [result removeObjectForKey:@"has_shipyard"];
        else
            [result removeObjectForKey:@"hasShipyard"];
    }   
    return result;
}

◆ mergeShipRoles:forShipKey:intoProbabilityMap:

- (void) mergeShipRoles:	(NSString *)	roles
forShipKey:	(NSString *)	shipKey
intoProbabilityMap:	(NSMutableDictionary *)	probabilitySets

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                       :(NSString *)roles
             forShipKey:(NSString *)shipKey
     intoProbabilityMap:(NSMutableDictionary *)probabilitySets
{
    NSDictionary            *rolesAndWeights = nil;
    NSEnumerator            *roleEnum = nil;
    NSString                *role = nil;
    OOMutableProbabilitySet *probSet = nil;
 
    
    /*  probabilitySets is a dictionary whose keys are roles and whose values
        are mutable probability sets, whose values are ship keys.
        
        When creating new ships Oolite looks up this probability map.
        To upgrade all soliton 'thargon' roles to 'EQ_THARGON' we need
        to swap these roles here.
    */
    
    rolesAndWeights = OOParseRolesFromString(roles);
  // add default [shipKey] role
    NSMutableDictionary *mutable = [NSMutableDictionary dictionaryWithDictionary:rolesAndWeights];
    [mutable setObject:[NSNumber numberWithFloat:1.0] forKey:[[[NSString alloc] initWithFormat:@"[%@]",shipKey] autorelease]];
    rolesAndWeights = mutable;
    
    id thargonValue = [rolesAndWeights objectForKey:@"thargon"];
    if (thargonValue != nil && [rolesAndWeights objectForKey:@"EQ_THARGON"] == nil)
    {
        NSMutableDictionary *mutable = [NSMutableDictionary dictionaryWithDictionary:rolesAndWeights];
        [mutable setObject:thargonValue forKey:@"EQ_THARGON"];
        rolesAndWeights = mutable;
    }
    
    for (roleEnum = [rolesAndWeights keyEnumerator]; (role = [roleEnum nextObject]); )
    {
        probSet = [probabilitySets objectForKey:role];
        if (probSet == nil)
        {
            probSet = [OOMutableProbabilitySet probabilitySet];
            [probabilitySets setObject:probSet forKey:role];
        }
        
        [probSet setWeight:[rolesAndWeights oo_floatForKey:role] forObject:shipKey];
    }
}

◆ playerShipKeys

- (NSArray *) playerShipKeys

Definition at line 1820 of file OOShipRegistry.m.

{
    return _playerShips;
}

◆ probabilitySetForRole:

- (OOProbabilitySet *) probabilitySetForRole: (NSString *) role

Definition at line 1820 of file OOShipRegistry.m.

                                            :(NSString *)role
{
    if (role == nil)  return nil;
    return [_probabilitySets objectForKey:role];
}

◆ randomShipKeyForRole:

- (NSString *) randomShipKeyForRole: (NSString *) role

Provided by category OOShipRegistry(OOConveniences).

Definition at line 1820 of file OOShipRegistry.m.

                                   :(NSString *)role
{
    return [[self probabilitySetForRole:role] randomObject];
}

◆ release

- (void) release

implementation

Provided by category OOShipRegistry(Singleton).

Definition at line 1820 of file OOShipRegistry.m.

1725{}

◆ reload

+ (void) reload

Definition at line 1820 of file OOShipRegistry.m.

{
    if (sSingleton != nil)
    {
        /* CIM: 'release' doesn't work - the class definition
         * overrides it, so this leaks memory. Needs a proper reset
         * method for reloading the ship registry data instead */
        [sSingleton release];
        sSingleton = nil;
        
        (void) [self sharedRegistry];
    }
}

◆ removeUnusableEntries:shipMode:

- (BOOL) removeUnusableEntries:		(NSMutableDictionary *)	ioData
shipMode:		(BOOL)	shipMode

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                              :(NSMutableDictionary *)ioData shipMode:(BOOL)shipMode
{
    NSEnumerator            *shipKeyEnum = nil;
    NSString                *shipKey = nil;
    NSMutableDictionary     *shipEntry = nil;
    BOOL                    remove;
    NSString                *modelName = nil;
    
    // Clean out invalid entries and templates. (Iterates over a copy of keys since it mutates the dictionary.)
    for (shipKeyEnum = [[ioData allKeys] objectEnumerator]; (shipKey = [shipKeyEnum nextObject]); )
    {
        shipEntry = [ioData objectForKey:shipKey];
        remove = NO;
        
        if ([shipEntry oo_boolForKey:@"is_template"] || [shipEntry oo_boolForKey:@"_oo_deferred_remove"])  remove = YES;
        else if (shipMode && [[shipEntry oo_stringForKey:@"roles"] length] == 0 && ![shipEntry oo_boolForKey:@"_oo_is_subentity"] && ![shipEntry oo_boolForKey:@"_oo_is_effect"])
        {
            OOLogERR(@"shipData.load.error", @"the shipdata.plist entry \"%@\" specifies no %@.", shipKey, @"roles");
            remove = YES;
            OOStandardsError(@"Error in shipdata.plist");
        }
        else
        {
            modelName = [shipEntry oo_stringForKey:@"model"];
            if (shipMode && [modelName length] == 0)
            {
                OOLogERR(@"shipData.load.error", @"the shipdata.plist entry \"%@\" specifies no %@.", shipKey, @"model");
                OOStandardsError(@"Error in shipdata.plist");
                remove = YES;
            }
            else if ([modelName length] != 0 && [ResourceManager pathForFileNamed:modelName inFolder:@"Models"] == nil)
            {
                OOLogERR(@"shipData.load.error", @"the shipdata.plist entry \"%@\" specifies non-existent model \"%@\".", shipKey, modelName);
                OOStandardsError(@"Error in shipdata.plist");
                remove = YES;
            }
        }
        if (remove)  [ioData removeObjectForKey:shipKey];
    }
    
    return YES;
}

◆ retain

- (id) retain

implementation

Provided by category OOShipRegistry(Singleton).

Definition at line 1820 of file OOShipRegistry.m.

{
    return self;
}

◆ retainCount

- (NSUInteger) retainCount

implementation

Provided by category OOShipRegistry(Singleton).

Definition at line 1820 of file OOShipRegistry.m.

{
    return UINT_MAX;
}

◆ sanitizeConditions:

- (BOOL) sanitizeConditions: (NSMutableDictionary *) ioData

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                           :(NSMutableDictionary *)ioData
{
    NSEnumerator            *shipKeyEnum = nil;
    NSString                *shipKey = nil;
    NSMutableDictionary     *shipEntry = nil;
    NSMutableDictionary     *mutableShipyard = nil;
    NSArray                 *conditions = nil;
    NSArray                 *hasShipyard = nil;
    NSArray                 *shipyardConditions = nil;
    NSString        *condition_script = nil;
    NSString        *shipyard_condition_script = nil;
    
    NSMutableArray *conditionScripts = [[NSMutableArray alloc] init];
 
    for (shipKeyEnum = [[ioData allKeys] objectEnumerator]; (shipKey = [shipKeyEnum nextObject]); )
    {
        shipEntry = [ioData objectForKey:shipKey];
        conditions = [shipEntry objectForKey:@"conditions"];
        condition_script = [shipEntry oo_stringForKey:@"condition_script"];
        if (condition_script != nil)
        {
            if (![conditionScripts containsObject:condition_script])
            {
                [conditionScripts addObject:condition_script];
            }
        }
 
        hasShipyard = [shipEntry objectForKey:@"has_shipyard"];
        if (![hasShipyard isKindOfClass:[NSArray class]])  hasShipyard = nil;   // May also be fuzzy boolean
        if (hasShipyard == nil)
        {
            hasShipyard = [shipEntry objectForKey:@"hasShipyard"];
            if (![hasShipyard isKindOfClass:[NSArray class]])  hasShipyard = nil;   // May also be fuzzy boolean
        }
        shipyardConditions = [[shipEntry oo_dictionaryForKey:@"_oo_shipyard"] objectForKey:@"conditions"];
        shipyard_condition_script = [[shipEntry oo_dictionaryForKey:@"_oo_shipyard"] oo_stringForKey:@"condition_script"];
        if (shipyard_condition_script != nil)
        {
            if (![conditionScripts containsObject:shipyard_condition_script])
            {
                [conditionScripts addObject:shipyard_condition_script];
            }
        }
 
        
        if (conditions == nil && hasShipyard && shipyardConditions == nil)  continue;
        
        if (conditions != nil)
        {
            OOStandardsDeprecated([NSString stringWithFormat:@"The 'conditions' key is deprecated in shipdata entry %@",shipKey]);
            if (!OOEnforceStandards())
            {
                if ([conditions isKindOfClass:[NSArray class]])
                {
                    conditions = OOSanitizeLegacyScriptConditions(conditions, [NSString stringWithFormat:@"<shipdata.plist entry \"%@\">", shipKey]);
                }
                else
                {
                    OOLogWARN(@"shipdata.load.warning", @"conditions for shipdata.plist entry \"%@\" are not an array, ignoring.", shipKey);
                    conditions = nil;
                }
            
                if (conditions != nil)
                {
                    [shipEntry setObject:conditions forKey:@"conditions"];
                }
                else
                {
                    [shipEntry removeObjectForKey:@"conditions"];
                }
            }
        }
        
        if (hasShipyard != nil)
        {
            hasShipyard = OOSanitizeLegacyScriptConditions(hasShipyard, [NSString stringWithFormat:@"<shipdata.plist entry \"%@\" hasShipyard conditions>", shipKey]);
            OOStandardsDeprecated([NSString stringWithFormat:@"Use of legacy script conditions in the 'has_shipyard' key is deprecated in shipyard entry %@",shipKey]);
            if (!OOEnforceStandards())
            {
                if (hasShipyard != nil)
                {
                    [shipEntry setObject:hasShipyard forKey:@"has_shipyard"];
                }
                else
                {
                    [shipEntry removeObjectForKey:@"hasShipyard"];
                    [shipEntry removeObjectForKey:@"has_shipyard"];
                }
            }
        }
        
        if (shipyardConditions != nil)
        {
            OOStandardsDeprecated([NSString stringWithFormat:@"The 'conditions' key is deprecated in shipyard entry %@",shipKey]);
            if (!OOEnforceStandards())
            {
                mutableShipyard = [[[shipEntry oo_dictionaryForKey:@"_oo_shipyard"] mutableCopy] autorelease];
            
                if ([shipyardConditions isKindOfClass:[NSArray class]])
                {
                    shipyardConditions = OOSanitizeLegacyScriptConditions(shipyardConditions, [NSString stringWithFormat:@"<shipyard.plist entry \"%@\">", shipKey]);
                }
                else
                {
                    OOLogWARN(@"shipdata.load.warning", @"conditions for shipyard.plist entry \"%@\" are not an array, ignoring.", shipKey);
                    shipyardConditions = nil;
                }
            
                if (shipyardConditions != nil)
                {
                    [mutableShipyard setObject:shipyardConditions forKey:@"conditions"];
                }
                else
                {
                    [mutableShipyard removeObjectForKey:@"conditions"];
                }
            
                [shipEntry setObject:mutableShipyard forKey:@"_oo_shipyard"];
            }
        }
    }
 
    [[OOCacheManager sharedCache] setObject:conditionScripts forKey:@"ship conditions" inCache:@"condition scripts"];
    [conditionScripts release];
 
    return YES;
}

◆ setShipInfoForKey:with:

- (void) setShipInfoForKey:		(NSString *)	key
with:		(NSDictionary *)	newShipData

Definition at line 1820 of file OOShipRegistry.m.

                          :(NSString *)key with:(NSDictionary *)newShipData
{
    NSMutableDictionary *mutableDict = [NSMutableDictionary dictionaryWithDictionary:_shipData];
    [mutableDict setObject:OODeepCopy(newShipData) forKey:key];
    DESTROY(_shipData);
    _shipData = [[NSDictionary dictionaryWithDictionary:mutableDict] retain];
}

Referenced by ShipStaticSetShipDataForKey().

Here is the caller graph for this function:

◆ sharedRegistry

+ (OOShipRegistry *) sharedRegistry

Definition at line 1820 of file OOShipRegistry.m.

{
    if (sSingleton == nil)
    {
        sSingleton = [[self alloc] init];
    }
    
    return sSingleton;
}

Referenced by ShipStaticKeys(), ShipStaticKeysForRole(), ShipStaticRoles(), ShipStaticSetShipDataForKey(), ShipStaticShipDataForKey(), and StationAddShipToShipyard().

Here is the caller graph for this function:

◆ shipInfoForKey:

- (NSDictionary *) shipInfoForKey: (NSString *) key

Definition at line 1820 of file OOShipRegistry.m.

                                 :(NSString *)key
{
    return [_shipData objectForKey:key];
}

Referenced by ShipStaticShipDataForKey(), and StationAddShipToShipyard().

Here is the caller graph for this function:

◆ shipIsBallTurretForKey:inShipData:

- (BOOL) shipIsBallTurretForKey:		(NSString *)	shipKey
inShipData:		(NSDictionary *)	shipData

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                               :(NSString *)shipKey inShipData:(NSDictionary *)shipData
{
    // Test for presence of setup_actions containing initialiseTurret.
    NSArray                 *setupActions = nil;
    NSEnumerator            *actionEnum = nil;
    NSString                *action = nil;
    
    setupActions = [[shipData oo_dictionaryForKey:shipKey] oo_arrayForKey:@"setup_actions"];
    
    for (actionEnum = [setupActions objectEnumerator]; (action = [actionEnum nextObject]); )
    {
        if ([[ScanTokensFromString(action) objectAtIndex:0] isEqualToString:@"initialiseTurret"])  return YES;
    }
    
    if ([shipKey isEqualToString:@"ballturret"])
    {
        // compatibility for OXPs using old subentity declarations and the
        // core turret entity
        return YES;
    }
 
    return NO;
}

◆ shipKeys

- (NSArray *) shipKeys

Provided by category OOShipRegistry(OOConveniences).

Definition at line 1820 of file OOShipRegistry.m.

{
    return [_shipData allKeys];
}

Referenced by ShipStaticKeys().

Here is the caller graph for this function:

◆ shipKeysWithRole:

- (NSArray *) shipKeysWithRole: (NSString *) role

Provided by category OOShipRegistry(OOConveniences).

Definition at line 1820 of file OOShipRegistry.m.

                              :(NSString *)role
{
    return [[self probabilitySetForRole:role] allObjects];
}

Referenced by ShipStaticKeysForRole().

Here is the caller graph for this function:

◆ shipRoles

- (NSArray *) shipRoles

Provided by category OOShipRegistry(OOConveniences).

Definition at line 1820 of file OOShipRegistry.m.

{
    return [_probabilitySets allKeys];
}

Referenced by ShipStaticRoles().

Here is the caller graph for this function:

◆ shipyardInfoForKey:

- (NSDictionary *) shipyardInfoForKey: (NSString *) key

Definition at line 1820 of file OOShipRegistry.m.

                                     :(NSString *)key
{
    return [[self shipInfoForKey:key] objectForKey:@"_oo_shipyard"];
}

Referenced by StationAddShipToShipyard().

Here is the caller graph for this function:

◆ stripPrivateKeys:

- (BOOL) stripPrivateKeys: (NSMutableDictionary *) ioData

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                         :(NSMutableDictionary *)ioData
{
    NSEnumerator            *shipKeyEnum = nil;
    NSString                *shipKey = nil;
    NSMutableDictionary     *shipEntry = nil;
    NSEnumerator            *attrKeyEnum = nil;
    NSString                *attrKey = nil;
    
    for (shipKeyEnum = [ioData keyEnumerator]; (shipKey = [shipKeyEnum nextObject]); )
    {
        shipEntry = [ioData objectForKey:shipKey];
        
        for (attrKeyEnum = [shipEntry keyEnumerator]; (attrKey = [attrKeyEnum nextObject]); )
        {
            if ([attrKey hasPrefix:@"_oo_"])
            {
                [shipEntry removeObjectForKey:attrKey];
            }
        }
    }
    
    return YES;
}

◆ translateOldStandardBasicSubentityDeclaration:forShip:shipData:fatalError:

- (NSDictionary *) translateOldStandardBasicSubentityDeclaration:	(NSArray *)	tokens
forShip:	(NSString *)	shipKey
shipData:	(NSDictionary *)	shipData
fatalError:	(BOOL *)	outFatalError

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                                                :(NSArray *)tokens
                                                         forShip:(NSString *)shipKey
                                                        shipData:(NSDictionary *)shipData
                                                      fatalError:(BOOL *)outFatalError
{
    NSString                *subentityKey = nil;
    Vector                  position;
    Quaternion              orientation;
    NSMutableDictionary     *result = nil;
    BOOL                    isTurret, isDock = NO;
    
    subentityKey = [tokens oo_stringAtIndex:0];
    
    isTurret = [self shipIsBallTurretForKey:subentityKey inShipData:shipData];
    
    position.x = [tokens oo_floatAtIndex:1];
    position.y = [tokens oo_floatAtIndex:2];
    position.z = [tokens oo_floatAtIndex:3];
    
    orientation.w = [tokens oo_floatAtIndex:4];
    orientation.x = [tokens oo_floatAtIndex:5];
    orientation.y = [tokens oo_floatAtIndex:6];
    orientation.z = [tokens oo_floatAtIndex:7];
    
    if(orientation.w == 0 && orientation.x == 0 && orientation.y == 0 && orientation.z == 0) 
    {
        orientation.w = 1; // avoid dividing by zero.
        OOLogWARN(@"shipData.load.error", @"The ship %@ has an undefined orientation for its %@ subentity. Setting it now at (1,0,0,0)", shipKey, subentityKey);
    }
    
    quaternion_normalize(&orientation);
    
    if (!isTurret)
    {
        isDock = [subentityKey rangeOfString:@"dock"].location != NSNotFound;
    }
    
    result = [NSMutableDictionary dictionaryWithCapacity:5];
    [result setObject:isTurret ? @"ball_turret" : @"standard" forKey:@"type"];
    [result setObject:subentityKey forKey:@"subentity_key"];
    [result oo_setVector:position forKey:@"position"];
    [result oo_setQuaternion:orientation forKey:@"orientation"];
    if (isDock)  [result oo_setBool:YES forKey:@"is_dock"];
    
    OOLog(@"shipData.translateSubentity.standard", @"Translated subentity declaration \"%@\" to %@", [tokens componentsJoinedByString:@" "], result);
    
    return [[result copy] autorelease];
}

◆ translateOldStyleFlasherDeclaration:forShip:fatalError:

- (NSDictionary *) translateOldStyleFlasherDeclaration:	(NSArray *)	tokens
forShip:	(NSString *)	shipKey
fatalError:	(BOOL *)	outFatalError

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                                      :(NSArray *)tokens
                                               forShip:(NSString *)shipKey
                                            fatalError:(BOOL *)outFatalError
{
    Vector                  position;
    float                   size, frequency, phase, hue;
    NSDictionary            *colorDict = nil;
    NSDictionary            *result = nil;
    
    position.x = [tokens oo_floatAtIndex:1];
    position.y = [tokens oo_floatAtIndex:2];
    position.z = [tokens oo_floatAtIndex:3];
    
    hue = [tokens oo_floatAtIndex:4];
    frequency = [tokens oo_floatAtIndex:5];
    phase = [tokens oo_floatAtIndex:6];
    size = [tokens oo_floatAtIndex:7];
    
    colorDict = [NSDictionary dictionaryWithObject:[NSNumber numberWithFloat:hue] forKey:@"hue"];
    
    result = [NSDictionary dictionaryWithObjectsAndKeys:
              @"flasher", @"type",
              OOPropertyListFromVector(position), @"position",
              [NSArray arrayWithObject:colorDict], @"colors",
              [NSNumber numberWithFloat:frequency], @"frequency",
              [NSNumber numberWithFloat:phase], @"phase",
              [NSNumber numberWithFloat:size], @"size",
              nil];
    
    OOLog(@"shipData.translateSubentity.flasher", @"Translated flasher declaration \"%@\" to %@", [tokens componentsJoinedByString:@" "], result);
    
    return result;
}

◆ translateOldStyleSubentityDeclaration:forShip:shipData:fatalError:

- (NSDictionary *) translateOldStyleSubentityDeclaration:	(NSString *)	declaration
forShip:	(NSString *)	shipKey
shipData:	(NSDictionary *)	shipData
fatalError:	(BOOL *)	outFatalError

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                                        :(NSString *)declaration
                                                 forShip:(NSString *)shipKey
                                                shipData:(NSDictionary *)shipData
                                              fatalError:(BOOL *)outFatalError
{
    NSArray                 *tokens = nil;
    NSString                *subentityKey = nil;
    BOOL                    isFlasher;
    
    tokens = ScanTokensFromString(declaration);
    
    subentityKey = [tokens objectAtIndex:0];
    isFlasher = [subentityKey isEqualToString:@"*FLASHER*"];
    
    // Sanity check: require eight tokens.
    if ([tokens count] != 8)
    {
        if (!isFlasher)
        {
            OOLogERR(@"shipData.load.error.badSubentity", @"the shipdata.plist entry \"%@\" has a broken subentity definition \"%@\" (should have 8 tokens, has %lu).", shipKey, subentityKey, [tokens count]);
            *outFatalError = YES;
        }
        else
        {
            OOLogWARN(@"shipData.load.warning.badFlasher", @"the shipdata.plist entry \"%@\" has a broken flasher definition (should have 8 tokens, has %lu). This flasher will be ignored.", shipKey, [tokens count]);
        }
        return nil;
    }
    
    if (isFlasher)
    {
        return [self translateOldStyleFlasherDeclaration:tokens
                                                 forShip:shipKey
                                              fatalError:outFatalError];
    }
    else
    {
        return [self translateOldStandardBasicSubentityDeclaration:tokens
                                                           forShip:shipKey
                                                          shipData:shipData
                                                        fatalError:outFatalError];
    }
}

◆ validateNewStyleFlasherDeclaration:forShip:fatalError:

- (NSDictionary *) validateNewStyleFlasherDeclaration:	(NSDictionary *)	declaration
forShip:	(NSString *)	shipKey
fatalError:	(BOOL *)	outFatalError

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                                     :(NSDictionary *)declaration
                                              forShip:(NSString *)shipKey
                                           fatalError:(BOOL *)outFatalError
{
    NSMutableDictionary     *result = nil;
    Vector                  position = kZeroVector;
    NSArray                 *colors = nil;
    id                      colorDesc = nil;
    float                   size, frequency, phase, brightfraction;
    BOOL                    initiallyOn;
    
#define kDefaultFlasherColor @"redColor"
    
    // "Validate" is really "clean up", since all values have defaults.
    colors = [declaration oo_arrayForKey:@"colors"];
    if ([colors count] == 0)
    {
        colorDesc = [declaration objectForKey:@"color"];
        if (colorDesc == nil) colorDesc = kDefaultFlasherColor;
        if ([colorDesc isKindOfClass:[NSArray class]])
        {
            // an easy made error is adding an array to "color" instead of "colors"
            OOLogWARN(@"shipData.load.warning.flasher.badColor", @"changing flasher for ship %@ from a color to a colors definition.", shipKey);
            colors = colorDesc;
        }
        else
        {
            colors = [NSArray arrayWithObject:colorDesc];
        }
    }
    
    // Validate colours.
    NSMutableArray *validColors = [NSMutableArray arrayWithCapacity:[colors count]];
    foreach (colorDesc, colors)
    {
        OOColor *color = [OOColor colorWithDescription:colorDesc];
        if (color != nil)
        {
            [validColors addObject:[color normalizedArray]];
        }
        else
        {
            OOLogWARN(@"shipdata.load.warning.flasher.badColor", @"skipping invalid colour specifier for flasher for ship %@.", shipKey);
        }
    }
    // Ensure there's at least one.
    if ([validColors count] == 0)
    {
        [validColors addObject:kDefaultFlasherColor];
    }
    colors = validColors;
    
    position = [declaration oo_vectorForKey:@"position"];
    
    size = [declaration oo_floatForKey:@"size" defaultValue:8.0];
    
    if (size <= 0)
    {
        OOLogWARN(@"shipData.load.warning.flasher.badSize", @"skipping flasher of invalid size %g for ship %@.", size, shipKey);
        return nil;
    }
 
    brightfraction = [declaration oo_floatForKey:@"bright_fraction" defaultValue:0.5];
    if (brightfraction < 0.0 || brightfraction > 1.0)
    {
        OOLogWARN(@"shipData.load.warning.flasher.badFraction", @"skipping flasher of invalid bright fraction %g for ship %@.", brightfraction, shipKey);
        return nil;
    }
    
    frequency = [declaration oo_floatForKey:@"frequency" defaultValue:2.0];
    phase = [declaration oo_floatForKey:@"phase" defaultValue:0.0];
    initiallyOn = [declaration oo_boolForKey:@"initially_on" defaultValue:YES];
    
    result = [NSMutableDictionary dictionaryWithCapacity:8];
    [result setObject:@"flasher" forKey:@"type"];
    [result setObject:colors forKey:@"colors"];
    [result oo_setVector:position forKey:@"position"];
    [result setObject:[NSNumber numberWithFloat:size] forKey:@"size"];
    [result setObject:[NSNumber numberWithFloat:frequency] forKey:@"frequency"];
    if (phase != 0)  [result setObject:[NSNumber numberWithFloat:phase] forKey:@"phase"];
    [result setObject:[NSNumber numberWithFloat:brightfraction] forKey:@"bright_fraction"];
    [result setObject:[NSNumber numberWithBool:initiallyOn] forKey:@"initially_on"];
    
    return [[result copy] autorelease];
}

◆ validateNewStyleStandardSubentityDeclaration:forShip:fatalError:

- (NSDictionary *) validateNewStyleStandardSubentityDeclaration:	(NSDictionary *)	declaration
forShip:	(NSString *)	shipKey
fatalError:	(BOOL *)	outFatalError

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                                               :(NSDictionary *)declaration
                                                        forShip:(NSString *)shipKey
                                                     fatalError:(BOOL *)outFatalError
{
    NSMutableDictionary     *result = nil;
    NSString                *subentityKey = nil;
    Vector                  position = kZeroVector;
    Quaternion              orientation = kIdentityQuaternion;
    BOOL                    isTurret;
    BOOL                    isDock = NO;
    float                   fireRate = -1.0f; // out of range constants
    float                   weaponRange = -1.0f;
    float                   weaponEnergy = -1.0f;
    NSDictionary            *scriptInfo = nil;
    
    subentityKey = [declaration objectForKey:@"subentity_key"];
    if (subentityKey == nil)
    {
        OOLogERR(@"shipData.load.error.badSubentity", @"subentity declaration for ship %@ specifies no subentity_key.", shipKey);
        *outFatalError = YES;
        return nil;
    }
    
    isTurret = [[declaration oo_stringForKey:@"type"] isEqualToString:@"ball_turret"];
    if (isTurret)
    {
        fireRate = [declaration oo_floatForKey:@"fire_rate" defaultValue:-1.0f];
        if (fireRate < 0.25f && fireRate >= 0.0f)
        {
            OOLogWARN(@"shipData.load.warning.turret.badFireRate", @"ball turret fire rate of %g for subentity of ship %@ is invalid, using 0.25.", fireRate, shipKey);
            fireRate = 0.25f;
        }
        weaponRange = [declaration oo_floatForKey:@"weapon_range" defaultValue:-1.0f];
        if (weaponRange > TURRET_SHOT_RANGE * COMBAT_WEAPON_RANGE_FACTOR)
        {
            OOLogWARN(@"shipData.load.warning.turret.badWeaponRange", @"ball turret weapon range of %g for subentity of ship %@ is too high, using %.1f.", weaponRange, shipKey, TURRET_SHOT_RANGE * COMBAT_WEAPON_RANGE_FACTOR);
            weaponRange = TURRET_SHOT_RANGE * COMBAT_WEAPON_RANGE_FACTOR; // approx. range of primary plasma canon.
        }
 
        weaponEnergy = [declaration oo_floatForKey:@"weapon_energy" defaultValue:-1.0f];
        if (weaponEnergy > 100.0f)
            
        {
            OOLogWARN(@"shipData.load.warning.turret.badWeaponEnergy", @"ball turret weapon energy of %g for subentity of ship %@ is too high, using 100.", weaponEnergy, shipKey);
            weaponEnergy = 100.0f;
        }
    }
    else
    {
        isDock = [declaration oo_boolForKey:@"is_dock"];
    }
    
    position = [declaration oo_vectorForKey:@"position"];
    orientation = [declaration oo_quaternionForKey:@"orientation"];
    quaternion_normalize(&orientation);
    
    scriptInfo = [declaration oo_dictionaryForKey:@"script_info"];
    
    result = [NSMutableDictionary dictionaryWithCapacity:10];
    [result setObject:isTurret ? @"ball_turret" : @"standard" forKey:@"type"];
    [result setObject:subentityKey forKey:@"subentity_key"];
    [result oo_setVector:position forKey:@"position"];
    [result oo_setQuaternion:orientation forKey:@"orientation"];
    if (isDock) 
    {
        [result oo_setBool:YES forKey:@"is_dock"];
 
        NSString* docklabel = [declaration oo_stringForKey:@"dock_label" defaultValue:@"the docking bay"];
        [result setObject:docklabel forKey:@"dock_label"];
 
        BOOL dockable = [declaration oo_boolForKey:@"allow_docking" defaultValue:YES];
        BOOL playerdockable = [declaration oo_boolForKey:@"disallowed_docking_collides" defaultValue:NO];
        BOOL undockable = [declaration oo_boolForKey:@"allow_launching" defaultValue:YES];
 
        [result oo_setBool:dockable forKey:@"allow_docking"];
        [result oo_setBool:playerdockable forKey:@"disallowed_docking_collides"];
        [result oo_setBool:undockable forKey:@"allow_launching"];
 
    }
 
    if (isTurret)
    {
        // default constants are defined and set in shipEntity
        if (fireRate > 0) [result oo_setFloat:fireRate forKey:@"fire_rate"];
        if (weaponRange >= 0) [result oo_setFloat:weaponRange forKey:@"weapon_range"];
        if (weaponEnergy >= 0) [result oo_setFloat:weaponEnergy forKey:@"weapon_energy"];
    }
    
    if (scriptInfo != nil)
    {
        [result setObject:scriptInfo forKey:@"script_info"];
    }
    
    return [[result copy] autorelease];
}

◆ validateNewStyleSubentityDeclaration:forShip:fatalError:

- (NSDictionary *) validateNewStyleSubentityDeclaration:	(NSDictionary *)	declaration
forShip:	(NSString *)	shipKey
fatalError:	(BOOL *)	outFatalError

implementation

Provided by category OOShipRegistry(OODataLoader).

Definition at line 1820 of file OOShipRegistry.m.

                                                       :(NSDictionary *)declaration
                                                forShip:(NSString *)shipKey
                                             fatalError:(BOOL *)outFatalError
{
    NSString                *type = nil;
    
    type = [declaration oo_stringForKey:@"type"];
    if (type == nil)  type = @"standard";
    
    if ([type isEqualToString:@"flasher"])
    {
        return [self validateNewStyleFlasherDeclaration:declaration forShip:shipKey fatalError:outFatalError];
    }
    else if ([type isEqualToString:@"standard"] || [type isEqualToString:@"ball_turret"])
    {
        return [self validateNewStyleStandardSubentityDeclaration:declaration forShip:shipKey fatalError:outFatalError];
    }
    else
    {
        OOLogERR(@"shipData.load.error.badSubentity", @"subentity declaration for ship %@ does not declare a valid type (must be standard, flasher or ball_turret).", shipKey);
        *outFatalError = YES;
        return nil;
    }
}

Member Data Documentation

◆ _demoShips

- (NSArray*) _demoShips

private

Definition at line 40 of file OOShipRegistry.h.

◆ _effectData

- (NSDictionary*) _effectData

private

Definition at line 39 of file OOShipRegistry.h.

◆ _playerShips

- (NSArray*) _playerShips

private

Definition at line 41 of file OOShipRegistry.h.

◆ _probabilitySets

- (NSDictionary*) _probabilitySets

private

Definition at line 42 of file OOShipRegistry.h.

◆ _shipData

- (NSDictionary*) _shipData

private

Definition at line 38 of file OOShipRegistry.h.

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

src/Core/OOShipRegistry.h
src/Core/OOShipRegistry.m

Instance Methods

Class Methods

Private Attributes

Detailed Description

Method Documentation

◆ allocWithZone:

◆ applyLikeShips:withKey:

◆ autorelease

◆ buildRoleProbabilitySets

◆ canonicalizeAndTagSubentities:

◆ canonicalizeSubentityDeclaration:forShip:shipData:fatalError:

◆ copyWithZone:

◆ dealloc

◆ demoShipKeys

◆ effectInfoForKey:

◆ init

◆ loadAndApplyShipDataOverrides:

◆ loadAndMergeShipyard:

◆ loadCachedRoleProbabilitySets

◆ loadDemoShipConditions

◆ loadDemoShips

◆ loadShipData

◆ makeShipEntriesMutable:

◆ mergeShip:withParent:

◆ mergeShipRoles:forShipKey:intoProbabilityMap:

◆ playerShipKeys

◆ probabilitySetForRole:

◆ randomShipKeyForRole:

◆ release

◆ reload

◆ removeUnusableEntries:shipMode:

◆ retain

◆ retainCount

◆ sanitizeConditions:

◆ setShipInfoForKey:with:

◆ sharedRegistry

◆ shipInfoForKey:

◆ shipIsBallTurretForKey:inShipData:

◆ shipKeys

◆ shipKeysWithRole:

◆ shipRoles

◆ shipyardInfoForKey:

◆ stripPrivateKeys:

◆ translateOldStandardBasicSubentityDeclaration:forShip:shipData:fatalError:

◆ translateOldStyleFlasherDeclaration:forShip:fatalError:

◆ translateOldStyleSubentityDeclaration:forShip:shipData:fatalError:

◆ validateNewStyleFlasherDeclaration:forShip:fatalError:

◆ validateNewStyleStandardSubentityDeclaration:forShip:fatalError:

◆ validateNewStyleSubentityDeclaration:forShip:fatalError:

Member Data Documentation

◆ _demoShips

◆ _effectData

◆ _playerShips

◆ _probabilitySets

◆ _shipData