Exemple #1
0
def prefstring(df):
    # Get the smallthings ModBase raws, which is where this data will be coming from
    smallraws = getsmallraws()
    if not smallraws:
        return pydwarf.failure('Failed to read smallthings raws.')

    # Get all creatures
    smallcreatures = smallraws.allobj('CREATURE')
    dfcreaturesdict = df.objdict('CREATURE')

    # Add the new prefstrings
    failedcreatures = 0
    for smallcreature in smallcreatures:
        dfcreature = dfcreaturesdict.get(smallcreature.args[0])
        if not dfcreature:
            pydwarf.log.debug(
                'Found prefstrings for %s but there was no corresponding creature in the DF raws. Skipping.'
                % smallcreature)
            failedcreatures += 1
        else:
            prefs = smallcreature.allprop(exact_value='PREFSTRING',
                                          args_count=1)
            dfcreature.add(tokens=prefs.copy())
            pydwarf.log.debug('Added %d prefstrings to %s.' %
                              (len(prefs), dfcreature))

    # All done!
    if (len(smallcreatures) - failedcreatures):
        return pydwarf.success('Added prefstrings to %d creatures.' %
                               (len(smallcreatures) - failedcreatures))
    else:
        return pydwarf.failure('Added prefstrings to no creatures.')
def prefstring(df):
    # Get the smallthings ModBase raws, which is where this data will be coming from
    smallraws = getsmallraws()
    if not smallraws: return pydwarf.failure('Failed to read smallthings raws.')
    
    # Get all creatures
    smallcreatures = smallraws.allobj('CREATURE')
    dfcreaturesdict = df.objdict('CREATURE')
    
    # Add the new prefstrings
    failedcreatures = 0
    for smallcreature in smallcreatures:
        dfcreature = dfcreaturesdict.get(smallcreature.args[0])
        if not dfcreature:
            pydwarf.log.debug('Found prefstrings for %s but there was no corresponding creature in the DF raws. Skipping.' % smallcreature)
            failedcreatures += 1
        else:
            prefs = smallcreature.allprop(exact_value='PREFSTRING', args_count=1)
            dfcreature.add(tokens=prefs.copy())
            pydwarf.log.debug('Added %d prefstrings to %s.' % (len(prefs), dfcreature))
            
    # All done!
    if (len(smallcreatures) - failedcreatures):
        return pydwarf.success('Added prefstrings to %d creatures.' % (len(smallcreatures) - failedcreatures))
    else:
        return pydwarf.failure('Added prefstrings to no creatures.')
def restrictnobles_custom(raws, inclusions=None, exclusions=None):
    mountain = raws.get('ENTITY:MOUNTAIN')
    if mountain:
        positions = mountain.alluntil(exact_value='POSITION',
                                      until_exact_value='ENTITY')
        if inclusions:
            pydwarf.log.debug('Handling position inclusions %s...' %
                              inclusions)
            for inclusion in inclusions:
                for position in positions:
                    addwm(position, 'ALLOWED_CLASS:WITTY_%s' % inclusion)
                creature = raws.getobj('CREATURE', inclusion)
                if creature:
                    addwm(creature, 'CREATURE_CLASS:WITTY_%s' % inclusion)
                else:
                    return pydwarf.failure('Couldn\'t find CREATURE:%s.' %
                                           inclusion)
        if exclusions:
            pydwarf.log.debug('Handling position exclusions %s...' %
                              exclusions)
            for exclusion in exclusions:
                for position in positions:
                    addwm(position, 'REJECTED_CLASS:WITTY_%s' % exclusion)
                creature = raws.getobj('CREATURE', exclusion)
                if creature:
                    addwm(creature, 'CREATURE_CLASS:WITTY_%s' % exclusion)
                else:
                    return pydwarf.failure('Couldn\'t find CREATURE:%s.' %
                                           exclusion)
        return pydwarf.success('Restricted %d positions.' % len(positions))
    else:
        return pydwarf.failure('Couldn\'t find ENTITY:MOUNTAIN.')
def bauxitetoaluminum(df, aluminum_value=0.75, entities=default_entities, add_to_file=default_file):
    # Affect value of aluminum
    pydwarf.log.debug('Multiplying value of aluminum by %f.' % aluminum_value)
    try:
        aluminum = df.getobj('INORGANIC:ALUMINUM')
        if aluminum is None: return pydwarf.failure('Couldn\'t find aluminum token to affect its value.')
        matvaluetoken = aluminum.getprop('MATERIAL_VALUE')
        matvaluetoken.args[0] = int( float(matvaluetoken.args[0]) * aluminum_value )
    except:
        pydwarf.log.exception('Failed to affect value of aluminum.')
        return pydwarf.failure()
        
    # Add the reaction
    return pydwarf.urist.getfn('pineapple.utils.addobject')(
        df,
        type = 'REACTION',
        id = 'SMELT_BAUXITE_ALUMINUM_PINEAPPLE',
        tokens = '''
            [NAME:smelt aluminum from bauxite]
            [SMELTER]
            [REAGENT:1:STONE:NO_SUBTYPE:STONE:BAUXITE]
            [REAGENT:1:STONE:NO_SUBTYPE:STONE:CRYOLITE]
            [PRODUCT:100:1:BAR:NO_SUBTYPE:METAL:ALUMINUM]
            [FUEL]
        ''',
        add_to_file = add_to_file,
        permit_entities = entities
    )
def subterraneanplants(df):
    # Get subterranean plants
    subplants = []
    for plant in df.allobj('PLANT'):
        if plant.getprop('BIOME:SUBTERRANEAN_WATER'):
            subplants.append(plant)
    if not len(subplants): return pydwarf.failure('Found no subterranean plants.')
    
    # Ensure each has all four seasons
    pydwarf.log.info('Found %d subterranean plants. Modifying...' % len(subplants))
    modified = 0
    for subplant in subplants:
        seasontokens = subplant.allprop(value_in=seasons)
        if len(seasontokens) > 0 and len(seasontokens) < len(seasons):
            pydwarf.log.debug('Adding season tokens to %s...' % subplant)
            # First remove the existing tokens (To avoid making duplicates)
            for seasontoken in seasontokens:
                seasontoken.remove()
            # Then add all four anew
            for season in seasons:
                subplant.add(raws.token(value=season))
            modified += 1
        else:
            pydwarf.log.debug('Plant %s either has no seasonal tokens or already has all of them, skipping.' % subplant)
    
    # All done
    if modified > 0:
        return pydwarf.success('Made %d subterranean plants grow year-round.' % modified)
    else:
        return pydwarf.failure('All subterranean plants already grew year-round.')
Exemple #6
0
def bauxitetoaluminum(df,
                      aluminum_value=0.75,
                      entities=default_entities,
                      add_to_file=default_file):
    # Affect value of aluminum
    pydwarf.log.debug('Multiplying value of aluminum by %f.' % aluminum_value)
    try:
        aluminum = df.getobj('INORGANIC:ALUMINUM')
        if aluminum is None:
            return pydwarf.failure(
                'Couldn\'t find aluminum token to affect its value.')
        matvaluetoken = aluminum.getprop('MATERIAL_VALUE')
        matvaluetoken.args[0] = int(
            float(matvaluetoken.args[0]) * aluminum_value)
    except:
        pydwarf.log.exception('Failed to affect value of aluminum.')
        return pydwarf.failure()

    # Add the reaction
    return pydwarf.urist.getfn('pineapple.utils.addobject')(
        df,
        type='REACTION',
        id='SMELT_BAUXITE_ALUMINUM_PINEAPPLE',
        tokens='''
            [NAME:smelt aluminum from bauxite]
            [SMELTER]
            [REAGENT:1:STONE:NO_SUBTYPE:STONE:BAUXITE]
            [REAGENT:1:STONE:NO_SUBTYPE:STONE:CRYOLITE]
            [PRODUCT:100:1:BAR:NO_SUBTYPE:METAL:ALUMINUM]
            [FUEL]
        ''',
        add_to_file=add_to_file,
        permit_entities=entities)
def restrictnobles_custom(raws, inclusions=None, exclusions=None):
    mountain = raws.get('ENTITY:MOUNTAIN')
    if mountain:
        positions = mountain.alluntil(exact_value='POSITION', until_exact_value='ENTITY')
        if inclusions:
            pydwarf.log.debug('Handling position inclusions %s...' % inclusions)
            for inclusion in inclusions:
                for position in positions: addwm(position, 'ALLOWED_CLASS:WITTY_%s' % inclusion)
                creature = raws.get(exact_value='CREATURE', exact_args=[inclusion])
                if creature:
                    addwm(creature, 'CREATURE_CLASS:WITTY_%s' % inclusion)
                else:
                    return pydwarf.failure('Couldn\'t find CREATURE:%s.' % inclusion)
        if exclusions:
            pydwarf.log.debug('Handling position exclusions %s...' % exclusions)
            for exclusion in exclusions:
                for position in positions: addwm(position, 'REJECTED_CLASS:WITTY_%s' % exclusion)
                creature = raws.get(exact_value='CREATURE', exact_args=[exclusion])
                if creature:
                    addwm(creature, 'CREATURE_CLASS:WITTY_%s' % exclusion)
                else:
                    return pydwarf.failure('Couldn\'t find CREATURE:%s.' % exclusion)
        return pydwarf.success('Restricted %d positions.' % len(positions))
    else:
        return pydwarf.failure('Couldn\'t find ENTITY:MOUNTAIN.')
Exemple #8
0
def engraving(df):
    if 'descriptor_shape_umiman' in df:
        return pydwarf.failure('File descriptor_shape_umiman already exists.')

    # Get the smallthings ModBase raws, which is where this data will be coming from
    smallraws = getsmallraws()
    if not smallraws:
        return pydwarf.failure('Failed to read smallthings raws.')

    # Get existing words and shapes
    dfwordsdict = df.objdict('WORD')
    dfshapesdict = df.objdict('SHAPE')

    # Add a new file for the new shapes
    dfshapesfile = df.add('raw/objects/descriptor_shape_umiman.txt')
    dfshapesfile.add('OBJECT:DESCRIPTOR_SHAPE')
    shapesadded = 0

    # Add each shape
    smallshapes = smallraws['descriptor_shape_standard']
    if smallshapes is None:
        return pydwarf.failure(
            'Failed to find smallthings raws file named descriptor_shape_standard.'
        )
    for smallshape in smallshapes.all(exact_value='SHAPE'):
        if smallshape.args[
                0] not in dfshapesdict:  # Verify that the shape isn't already in the raws
            pydwarf.log.debug('Adding shape %s...' % smallshape)

            # Get the tokens describing this shape
            smallshapetokens = smallshape.all(until_exact_value='SHAPE')

            # Shapes in DF's descriptor_shape_standard all have a [WORD:X] token but these do not
            # To compensate, let's do our best to map each shape to a word automatically
            smallshapename = smallshape.get(exact_value='NAME', args_count=2)
            if smallshapename:
                useshapename = smallshapename.args[0].upper()
                if useshapename in shapenamedict:
                    useshapename = shapenamedict[useshapename]
                shapeword = dfwordsdict.get(useshapename)
            else:
                pydwarf.log.error('Found no names for %s.' % shallshape)

            # Actually add the new shape to the raws
            dfshapesfile.add(smallshape.copy())
            dfshapesfile.add(smallshapetokens.copy())

            # And also add the word, provided one was found
            if shapeword:
                dfshapesfile.add(
                    raws.token(value='WORD', args=(shapeword.args[0], )))
            else:
                pydwarf.log.info('Found no word for %s, named %s.' %
                                 (smallshape, smallshapename))

            # And on to the next iteration
            shapesadded += 1

    # All done!
    return pydwarf.success('Added %s new shapes.' % shapesadded)
Exemple #9
0
def orientation(df,
                creatures=default_creatures,
                mode='hetero',
                lover_chance=default_lover_chance):
    if isinstance(mode, basestring):
        if mode not in mode_info:
            return pydwarf.failure(
                'Invalid mode %s. Recognized modes are these: %s.' %
                (mode, ', '.join(mode_tokens.keys())))
        usemode = mode_info[mode]
    else:
        usemode = mode

    # Unpack variables for convenience
    disinterestsame, loversame, commitsame, disinterestother, loverother, commitother = usemode

    # Get tokens for all the specified creatures
    creatures = df.allobj(type='CREATURE', id_in=creatures)
    pydwarf.log.debug('Found %d applicable creatures.' % len(creatures))

    # Add tokens after [FEMALE] and [MALE] tokens
    added = 0
    for creature in creatures:
        pydwarf.log.debug('Applying ORIENTATION changes to %s.' % creature)

        # Remove any existing ORIENTATION tokens
        removetokens = creature.allprop(exact_value='ORIENTATION')
        if len(removetokens):
            pydwarf.log.debug(
                'Removing %d existing ORIENTATION tokens from token %s.' %
                (len(removetokens), gendertoken))
            for removetoken in removetokens:
                removetoken.remove()

        # Add the new orientation tokens
        gendertokens = creature.allprop(value_in=('FEMALE', 'MALE'),
                                        args_count=0)
        for gendertoken in gendertokens:
            othergender = 'FEMALE' if gendertoken.value == 'MALE' else 'MALE'
            gendertoken.add(
                raws.token(value='ORIENTATION',
                           args=[
                               othergender, disinterestother, loverother,
                               commitother
                           ]))
            gendertoken.add(
                raws.token(value='ORIENTATION',
                           args=[
                               gendertoken.value, disinterestsame, loversame,
                               commitsame
                           ]))
            added += 1

    # All done!
    if added > 0:
        return pydwarf.success(
            'Appended ORIENTATION tokens after %d gender tokens.' % added)
    else:
        return pydwarf.failure('Found no gender tokens to add ORIENTATION to.')
def addhack(df, auto_run, onload=True, startup=False, **kwargs):
    name = kwargs.get('name', kwargs.get('path', 'unnamed'))
    
    onload_path = 'raw/onLoad.init'
    startup_path = 'dfhack.init'
    
    if kwargs: 
        pydwarf.log.debug('Adding new file %s.' % name)
        hackfile = df.add(**kwargs)
    else:
        hackfile = None
    
    if auto_run:
        if auto_run is True:
            if not hackfile: return pydwarf.failure('Failed to add lines to DFHack because auto_run was True but no file was created.')
            auto_run = '\n%s' % hackfile.name
        
        pydwarf.log.debug('Adding text %s to the end of dfhack.init.' % auto_run)
        addtext = '\n%s\n' % auto_run
        
        if onload:
            if onload_path not in df:
                init = df.add(
                    loc = 'raw',
                    name = 'onLoad',
                    ext = '.init',
                    kind = raws.binfile
                )
            else:
                init = df[onload_path]
            init.add(addtext)
            
        if startup:
            if startup_path not in df:
                if 'dfhack.init-example' in df:
                    pydwarf.log.info('Copying dfhack.init-example to new file dfhack.init before adding new content to the file.')
                    init = df['dfhack.init-example'].copy().bin()
                    init.name = startup_path
                    df.add(file=init)
                else:
                    return pydwarf.failure('Failed to locate dfhack.init or dfhack.init-example.')
            else:
                init = df[startup_path].bin()
            init.add(addtext)
        
        return pydwarf.success(
            'Added text to %s: "%s"' % (
                ' and '.join(
                    item for item in (
                        onload_path if onload else None, startup_path if startup else None
                    ) if item
                ),
                auto_run
            )
        )
        
    else:
        return pydwarf.success('Added new file %s.' % name)
Exemple #11
0
def addhack(df, auto_run, onload=True, startup=False, **kwargs):
    name = kwargs.get('name', kwargs.get('path', 'unnamed'))

    onload_path = 'raw/onLoad.init'
    startup_path = 'dfhack.init'

    if kwargs:
        pydwarf.log.debug('Adding new file %s.' % name)
        hackfile = df.add(**kwargs)
    else:
        hackfile = None

    if auto_run:
        if auto_run is True:
            if not hackfile:
                return pydwarf.failure(
                    'Failed to add lines to DFHack because auto_run was True but no file was created.'
                )
            auto_run = '\n%s' % hackfile.name

        pydwarf.log.debug('Adding text %s to the end of dfhack.init.' %
                          auto_run)
        addtext = '\n%s\n' % auto_run

        if onload:
            if onload_path not in df:
                init = df.add(loc='raw',
                              name='onLoad',
                              ext='.init',
                              kind=raws.binfile)
            else:
                init = df[onload_path]
            init.add(addtext)

        if startup:
            if startup_path not in df:
                if 'dfhack.init-example' in df:
                    pydwarf.log.info(
                        'Copying dfhack.init-example to new file dfhack.init before adding new content to the file.'
                    )
                    init = df['dfhack.init-example'].copy().bin()
                    init.name = startup_path
                    df.add(file=init)
                else:
                    return pydwarf.failure(
                        'Failed to locate dfhack.init or dfhack.init-example.')
            else:
                init = df[startup_path].bin()
            init.add(addtext)

        return pydwarf.success(
            'Added text to %s: "%s"' %
            (' and '.join(item for item in (onload_path if onload else None,
                                            startup_path if startup else None)
                          if item), auto_run))

    else:
        return pydwarf.success('Added new file %s.' % name)
def trans(dfraws, species=default_species, beards=True, frequency=500):
    # Add new interaction
    pydwarf.log.debug('Adding sterility interaction...')
    objinteraction = dfraws.get('OBJECT:INTERACTION')
    if objinteraction:
        objinteraction.add(pretty=add_sterile_interaction)
    else:
        return pydwarf.failure('Unable to add sterility interaction.')
    
    # Add new castes
    creaturetokendict = dfraws.objdict('CREATURE')
    castefailures = []
    for creature in species:
        pydwarf.log.debug('Handling creature %s...' % creature)
        creaturetoken = creaturetokendict.get(creature)
        if creaturetoken:
            castes = creaturetoken.alluntil(exact_value='CASTE', args_count=1, until_exact_value='CREATURE')
            if len(castes) == 2 and ((castes[0].args[0] == 'MALE' and castes[1].args[0] == 'FEMALE') or (castes[1].args[0] == 'MALE' and castes[0].args[0] == 'FEMALE')):
                
                # Remove DESCRIPTION token from the creature and add it to each caste
                descriptiontoken = creaturetoken.get(exact_value='DESCRIPTION', args_count=1)
                if descriptiontoken:
                    descriptiontoken.remove()
                    for castetoken in castes: castetoken.add(token=raws.token.copy(descriptiontoken))
                
                # Handle existing castes
                for caste in castes:
                    # Add beards to dwarven women
                    if beards and caste.args[0] == 'FEMALE': caste.add(pretty=add_beard_tokens)
                    # Add population ratio token
                    caste.add(raws.token(value='POP_RATIO', args=[str(frequency)]))
                
                # Add each new caste
                for castename, castedict in additional_castes.iteritems():
                    castetoken = castes[0].add(raws.token(value='CASTE', args=[castename]), reverse=True)
                    # Every new caste gets these tokens
                    castetoken.add(pretty=add_trans_tokens)
                    # Add beards to new dwarf castes
                    if beards and creature == 'DWARF': castetoken.add(pretty=add_beard_tokens)
                    # Tokens unique to each new caste
                    if 'addtokens' in castedict: castetoken.add(pretty=castedict['addtokens'])
                    # Add the caste-specific description
                    description = ' '.join((descriptiontoken.args[0], castedict['description'])) if descriptiontoken else castedict['description']
                    castetoken.add(raws.token(value='DESCRIPTION', args=[description]))
                    
            else:
                pydwarf.log.error('Unexpected castes for creature %s: %s.' % (creature, castes))
                castefailures.append(creature)
        
        else:
            pydwarf.log.error('Failed to find token for creature %s.' % creature)
            castefailures.append(creature)
    
    if len(castefailures) == 0:
        return pydwarf.success('Added new castes to %d creatures.' % len(species))
    else:
        return pydwarf.failure('Added new castes to %d creatures, but failed to add castes to %s.' % (len(species) - len(castefailures), castefailures))
Exemple #13
0
def addreaction(df, id, tokens, add_to_file='reaction_custom', permit_entities=None):
    if permit_entities is not None and (not addtoentity(df, permit_entities, permitted_reaction=(id,)).success):
        return pydwarf.failure('Failed to add permitted reactions to entites.')
    else:
        if df.getobj(type='REACTION', exact_id=id):
            return pydwarf.failure('Reaction %s already exists.' % id)
        else:
            rfile = df.getfile(add_to_file, create=True)
            rfile.add(raws.token(value='REACTION', args=[id], prefix='\n\n')).add(tokens)
            return pydwarf.success('Added reaction %s to file %s and entities %s.' % (id, add_to_file, permit_entities))
def engraving(df):
    if 'descriptor_shape_umiman' in df: return pydwarf.failure('File descriptor_shape_umiman already exists.')
        
    # Get the smallthings ModBase raws, which is where this data will be coming from
    smallraws = getsmallraws()
    if not smallraws: return pydwarf.failure('Failed to read smallthings raws.')
    
    # Get existing words and shapes
    dfwordsdict = df.objdict('WORD')
    dfshapesdict = df.objdict('SHAPE')
    
    # Add a new file for the new shapes
    dfshapesfile = df.add('raw/objects/descriptor_shape_umiman.txt')
    dfshapesfile.add('OBJECT:DESCRIPTOR_SHAPE')
    shapesadded = 0
    
    # Add each shape
    smallshapes = smallraws['descriptor_shape_standard']
    if smallshapes is None: return pydwarf.failure('Failed to find smallthings raws file named descriptor_shape_standard.')
    for smallshape in smallshapes.all(exact_value='SHAPE'):
        if smallshape.args[0] not in dfshapesdict: # Verify that the shape isn't already in the raws
            pydwarf.log.debug('Adding shape %s...' % smallshape)
            
            # Get the tokens describing this shape
            smallshapetokens = smallshape.all(until_exact_value='SHAPE')
            
            # Shapes in DF's descriptor_shape_standard all have a [WORD:X] token but these do not
            # To compensate, let's do our best to map each shape to a word automatically
            smallshapename = smallshape.get(exact_value='NAME', args_count=2)
            if smallshapename:
                useshapename = smallshapename.args[0].upper()
                if useshapename in shapenamedict: useshapename = shapenamedict[useshapename]
                shapeword = dfwordsdict.get(useshapename)
            else:
                pydwarf.log.error('Found no names for %s.' % shallshape)
                
            # Actually add the new shape to the raws
            dfshapesfile.add(smallshape.copy())
            dfshapesfile.add(smallshapetokens.copy())
            
            # And also add the word, provided one was found
            if shapeword:
                dfshapesfile.add(raws.token(value='WORD', args=(shapeword.args[0],)))
            else:
                pydwarf.log.info('Found no word for %s, named %s.' % (smallshape, smallshapename))
            
            # And on to the next iteration
            shapesadded += 1
    
    # All done!
    return pydwarf.success('Added %s new shapes.' % shapesadded)
def permitobject(df, type=None, id=None, permit_entities=None, all_entities=False, item_rarity=None):
    # Decide what tokens need to be added to the entities based on the object type
    if type == 'REACTION':
        tokens = raws.token(value='PERMITTED_REACTION', args=[id])
    elif type.startswith('BUILDING_'):
        tokens = raws.token(value='PERMITTED_BUILDING', args=[id])
    elif type.startswith('ITEM_'):
        value = type.split('_')[1]
        args = [id, item_rarity] if item_rarity else [id]
        tokens = raws.token(value=value, args=args)
    else:
        tokens = None
    
    pydwarf.log.debug('Permitting object [%s:%s] for %s entities.' % (
        type, id, 'all' if all_entities == '*' else len(permit_entities)
    ))
    
    # Actually add those tokens
    if tokens is None:
        return pydwarf.success('Didn\'t actually permit object [%s:%s] because objects of this type cannot be permitted.' % (type, id))
    elif not permit_entities:
        return pydwarf.failure('No entities were given for permitting.')
    else:
        response = addtoentity(
            df,
            entities = permit_entities,
            tokens = tokens
        )
        if not response:
            return response
        else:
            return pydwarf.success('Permitted object [%s:%s] for %d entities.' % (type, id, len(permit_entities)))
def metalitems(df, metals=default_metals, items=default_item_tokens):
    # Handle each metal
    modified = 0
    for inorganictoken in df.allobj('INORGANIC'):
        if inorganictoken.args[0] in metals:
            metal = inorganictoken.args[0]
            pydwarf.log.debug('Handling metal %s...' % metal)
            itemtokens = inorganictoken.allprop(value_in=items)
            if len(itemtokens) < len(items):
                pydwarf.log.debug('Adding tokens to metal %s...' % metal)
                # Remove existing item tokens from the list (To avoid making duplicates)
                for itemtoken in itemtokens:
                    itemtoken.remove()
                # Add new ones
                templatetoken = inorganictoken.getlastprop('USE_MATERIAL_TEMPLATE')
                addaftertoken = templatetoken if templatetoken else inorganictoken
                for item in items:
                    addaftertoken.add(item)
                modified += 1
            else:
                pydwarf.log.debug('Metal %s already allows all the item types specified, skipping.' % metal)
            
    # All done
    if modified > 0:
        return pydwarf.success('Added tokens to %d metals.' % modified)
    else:
        return pydwarf.failure('No tokens were added to any metals.')
Exemple #17
0
def stoneclarity(dfraws, rules=default_rules, query=default_inorganics_query, fuels=None):
    if rules and len(rules):
        groups, ids = builddicts(query, dfraws, fuels if fuels else autofuels(dfraws, pydwarf.log), pydwarf.log)
        applyrules(rules, groups, ids)
        return pydwarf.success('Finished applying %d rules to %d inorganic groups and %d inorganic ids.' % (len(rules), len(groups), len(ids)))
    else:
        return pydwarf.failure('I was given no rules to follow.')
def controllable(df, entities='*'):
    controllable = set()
    
    if entities == '*': # Enable all entities
        for entity in df.allobj('ENTITY'):
            entity.setprop('SITE_CONTROLLABLE')
            controllable.add(entity.args[0])
    else: # Enable listed entities and disable others
        entities = set([entities]) if isinstance(entities, basestring) else set(entities)
        for entity in df.allobj('ENTITY'):
            if entity.args[0] in entities:
                entity.setprop('SITE_CONTROLLABLE')
                controllable.add(entity.args[0])
                entities.remove(entity.args[0])
            else:
                entity.removeprop('SITE_CONTROLLABLE')
        if entities:
            pydwarf.log.error(
                'Nonexistent objects in controllable entities list: %s' % ', '.join(entities)
            )
                
    if controllable:
        return pydwarf.success('Assigned %d controllable entities.' % len(controllable))
    else:
        return pydwarf.failure('Assigned no controllable entities.')
def butcherinorganic(df, templates=default_templates):
    added = 0

    # Apply BUTCHER_SPECIAL tokens to material templates
    for templatename, butcherspecial in templates.iteritems():
        template = df.getobj(type='MATERIAL_TEMPLATE', exact_id=templatename)
        if template:
            pydwarf.log.debug(
                'Adding BUTCHER_SPECIAL item %s to material template %s.' %
                (butcherspecial, templatename))
            template.addprop(
                raws.token(value='BUTCHER_SPECIAL',
                           args=[butcherspecial, 'NONE']))
            added += 1
        else:
            pydwarf.log.error('Unable to find template %s, skipping.' %
                              templatename)

    # All done!
    if added > 0:
        return pydwarf.success(
            'Added BUTCHER_SPECIAL to %d material templates.' % added)
    else:
        return pydwarf.failure(
            'Added BUTCHER_SPECIAL to no material templates.')
def stoneclarity(dfraws, rules=default_rules, query=default_inorganics_query, fuels=None):
    if rules and len(rules):
        groups, ids = builddicts(query, dfraws, fuels if fuels else autofuels(dfraws, pydwarf.log), pydwarf.log)
        applyrules(rules, groups, ids)
        return pydwarf.success('Finished applying %d rules to %d inorganic groups and %d inorganic ids.' % (len(rules), len(groups), len(ids)))
    else:
        return pydwarf.failure('I was given no rules to follow.')
def noaquifers(df):
    aquifers = df.all('AQUIFER')
    if len(aquifers):
        for aquifer in aquifers: aquifer.remove()
        return pydwarf.success('Removed %d AQUIFER tokens.' % len(aquifers))
    else:
        return pydwarf.failure('Found no AQUIFER tokens.')
Exemple #22
0
def permitobject(df,
                 type=None,
                 id=None,
                 permit_entities=None,
                 item_rarity=None):
    # Decide what tokens need to be added to the entities based on the object type
    if type == 'REACTION':
        tokens = raws.token(value='PERMITTED_REACTION', args=[id])
    elif type.startswith('BUILDING_'):
        tokens = raws.token(value='PERMITTED_BUILDING', args=[id])
    elif type.startswith('ITEM_'):
        value = type.split('_')[1]
        args = [id, item_rarity] if item_rarity else [id]
        tokens = raws.token(value=value, args=args)
    else:
        tokens = None

    pydwarf.log.debug('Permitting object [%s:%s] for %d entities.' %
                      (type, id, len(permit_entities)))

    # Actually add those tokens
    if tokens is None:
        return pydwarf.success(
            'Didn\'t actually permit object [%s:%s] because objects of this type cannot be permitted.'
            % (type, id))
    elif not permit_entities:
        return pydwarf.failure('No entities were given for permitting.')
    else:
        response = addtoentity(df, entities=permit_entities, tokens=tokens)
        if not response:
            return response
        else:
            return pydwarf.success(
                'Permitted object [%s:%s] for %d entities.' %
                (type, id, len(permit_entities)))
def fantastic(df, dwarves=dwarf_entities):
    # Add properties to various inorganics as defined by the add_properties dict
    errors = 0
    for identifier, re_id, addprops in add_properties:
        additions = df.allobj(type='INORGANIC', re_id=re_id).each(
            lambda token: token.addprop(addprops), none=True)
        if len(additions):
            pydwarf.log.debug('Added %s properties to %d inorganics.' %
                              (identifier, len(additions)))
        else:
            errors += 1
            pydwarf.log.error(
                'Failed to add %s properties because no matching inorganics were found.'
                % identifier)

    for path in add_paths:
        pydwarf.log.debug('Adding file at %s.' % path)
        df.add(path=path, loc='raw/objects')

    for path in patch_paths:
        response = pydwarf.urist.getfn('pineapple.easypatch')(
            df, files=path, loc='raw/objects', permit_entities=dwarves)
        if not response: return response

    if not errors:
        return pydwarf.success()
    else:
        return pydwarf.failure(
            'Failed to add inorganic properties for %d groups.' % errors)
Exemple #24
0
def objecttokens(df, object_type, token, add_to=None, remove_from=None):
    added, removed = 0, 0

    # Remove tokens
    if remove_from:
        for objtoken in df.allobj(
                type=object_type,
                id_in=(None if remove_from == '*' else remove_from)):
            for removetoken in objtoken.allprop(token):
                removetoken.remove()
                removed += 1

    # Add tokens
    if add_to:
        for objtoken in df.allobj(type=object_type,
                                  id_in=(None if add_to == '*' else add_to)):
            if not objtoken.getprop(token):
                objtoken.addprop(token)
                added += 1

    # All done!
    if removed or added:
        return pydwarf.success(
            'Added %d %s tokens and removed %d from object type %s.' %
            (added, token, removed, object_type))
    else:
        return pydwarf.failure('Didn\'t add or remove any %s tokens.' % token)
def materialsplus(df, entities=default_entities):
    # Add properties to various inorganics as defined by the add_properties dict
    errors = 0
    for identifier, re_id, addprops in add_properties:
        additions = df.allobj(type='INORGANIC', re_id=re_id).each(
            lambda token: token.addprop(addprops), none=True
        )
        if len(additions):
            pydwarf.log.debug('Added %s properties to %d inorganics.' % (identifier, len(additions)))
        else:
            errors += 1
            pydwarf.log.error('Failed to add %s properties because no matching inorganics were found.' % identifier)
    
    for path in add_paths:
        pydwarf.log.debug('Adding file at %s.' % path)
        df.add(path=path, loc='raw/objects')
    
    for path in patch_paths:
        response = pydwarf.urist.getfn('pineapple.easypatch')(
            df,
            files = path,
            loc = 'raw/objects',
            permit_entities = entities
        )
        if not response: return response
    
    if not errors:
        return pydwarf.success()
    else:
        return pydwarf.failure('Failed to add inorganic properties for %d groups.' % errors)
Exemple #26
0
def maxage(df, required_property=default_required_property, apply_to_creatures=None):
    removedfrom = []
    creaturedict = df.objdict('CREATURE')
    
    # Handle by properties
    if required_property:
        remove_all = len(required_property) == 1 and required_property[0] == '*'
        for creaturename, creaturetoken in creaturedict.iteritems():
            if remove_all or (creaturetoken.getprop(value_in=required_property) is not None):
                maxage = creaturetoken.getprop('MAXAGE')
                if maxage: maxage.remove(); removedfrom.append(creaturetoken)
                    
    # Handle by creature names
    if apply_to_creatures:
        for creaturename in apply_to_creatures:
            creaturetoken = creaturedict.get(creaturename)
            if creaturetoken:
                maxage = creaturetoken.getprop('MAXAGE')
                if maxage: maxage.remove(); removedfrom.append(creaturetoken)
            else:
                pydwarf.log.error('Couldn\'t find creature %s for removal of MAXAGE token.' % creaturename)
                
    # All done!
    pydwarf.log.debug('Removed MAXAGE tokens from creatures: %s.' % [token.args[0] for token in removedfrom])
    if len(removedfrom):
        return pydwarf.success('Removed MAXAGE tokens from %d creatues.' % len(removedfrom))
    else:
        return pydwarf.failure('Found no MAXAGE tokens to remove.')
        
Exemple #27
0
def controllable(df, entities='*'):
    controllable = set()

    if entities == '*':  # Enable all entities
        for entity in df.allobj('ENTITY'):
            entity.setprop('SITE_CONTROLLABLE')
            controllable.add(entity.args[0])
    else:  # Enable listed entities and disable others
        entities = set([entities]) if isinstance(entities,
                                                 basestring) else set(entities)
        for entity in df.allobj('ENTITY'):
            if entity.args[0] in entities:
                entity.setprop('SITE_CONTROLLABLE')
                controllable.add(entity.args[0])
                entities.remove(entity.args[0])
            else:
                entity.removeprop('SITE_CONTROLLABLE')
        if entities:
            pydwarf.log.error(
                'Nonexistent objects in controllable entities list: %s' %
                ', '.join(entities))

    if controllable:
        return pydwarf.success('Assigned %d controllable entities.' %
                               len(controllable))
    else:
        return pydwarf.failure('Assigned no controllable entities.')
Exemple #28
0
def addtoentity(df, entities, tokens):
    if entities == '*':
        pydwarf.log.debug('Adding tokens to all entities.')
        entitytokens = df.allobj(type='ENTITY')
    else:
        if isinstance(entities, basestring):
            entities = (entities, )
        pydwarf.log.debug('Adding tokens to entities %s.' %
                          ', '.join(str(ent) for ent in entities))
        entitytokens = df.allobj(type='ENTITY', id_in=entities)

    for entitytoken in entitytokens:
        entitytoken.addprop(tokens)
        if isinstance(tokens, raws.queryable):
            tokens = raws.helpers.copy(
                tokens
            )  # TODO: What about other iterables containing token objects, e.g. lists and tuples?

    if entities != '*' and len(entitytokens) != len(entities):
        return pydwarf.failure(
            'Failed to add tokens to all given entities because only %d of %d exist.'
            % (len(entitytokens), len(entities)))
    else:
        return pydwarf.success('Added tokens to %d entities.' %
                               len(entitytokens))
def noaquifers(df):
    # Do the removing
    aquifers = df.removeall('AQUIFER')
    # All done!
    if len(aquifers):
        return pydwarf.success('Removed %d AQUIFER tokens.' % len(aquifers))
    else:
        return pydwarf.failure('Found no AQUIFER tokens.')
def noaquifers(df):
    # Do the removing
    aquifers = df.removeall('AQUIFER')
    # All done!
    if len(aquifers):
        return pydwarf.success('Removed %d AQUIFER tokens.' % len(aquifers))
    else:
        return pydwarf.failure('Found no AQUIFER tokens.')
Exemple #31
0
def flybears(raws):
    bears = raws.allobj('CREATURE', re_id='BEAR_.+')
    for bear in bears:
        bear.get('CASTE:FEMALE').add('FLIER')
    if len(bears):
        return pydwarf.success('Made %d bear species fliers.' % len(bears))
    else:
        return pydwarf.failure('Couldn\'t find any bears to make fliers.')
Exemple #32
0
def nograzers(raws):
    grazers = raws.all(exact_value='GRAZER')
    standardgrazers = raws.all('STANDARD_GRAZER')
    for grazer in grazers: grazer.remove()
    for grazer in standardgrazers: grazer.remove()
    if len(grazers) or len(standardgrazers):
        return pydwarf.success('Removed %d GRAZER and %d STANDARD_GRAZER tokens.' % (len(grazers), len(standardgrazers)))
    else:
        return pydwarf.failure('I found no grazer tokens to replace.')
def deerappear(df, creature='DEER', tile="'d'", color=['6','0','1']):
    # Find the first token that looks like [CREATURE:DEER]
    deertoken = df.getobj('CREATURE', creature)
    if deertoken:
        # Find the first token, following [CREATURE:DEER], that looks like [CREATURE_TILE:'D']
        deertile = deertoken.getprop(exact_value='CREATURE_TILE', args_count=1)
        # Find the first token, following [CREATURE:DEER], that looks like [COLOR:6:0:0]
        deercolor = deertoken.getprop(exact_value='COLOR', args_count=3)
        if deertile and deercolor:
            # Change the token to look like [CREATURE_TILE:'d']
            deertile.args[0] = tile
            # Change the token to look like [COLOR:6:0:1]
            deercolor.args = color
            return pydwarf.success()
        else:
            return pydwarf.failure('Didn\'t find CREATURE_TILE and COLOR tokens as expected.')
    else:
        return pydwarf.failure('I couldn\'t find the deer token.')
def noexotic(df):
    pets = df.all('PET_EXOTIC')
    mounts = df.all('MOUNT_EXOTIC')
    for token in pets: token.value = 'PET'
    for token in mounts: token.value = 'MOUNT'
    if len(pets) or len(mounts):
        return pydwarf.success('Replaced %d PET_EXOTIC and %d MOUNT_EXOTIC tokens.' % (len(pets), len(mounts)))
    else:
        return pydwarf.failure('I found no PET_EXOTIC or MOUNT_EXOTIC tokens to replace.')
Exemple #35
0
def deerappear(raws, creature='DEER', tile="'d'", color=['6','0','1']):
    # Find the first token that looks like [CREATURE:DEER]
    deertoken = raws.getobj('CREATURE', creature)
    if deertoken:
        # Find the first token, following [CREATURE:DEER], that looks like [CREATURE_TILE:'D']
        deertile = deertoken.getuntil(exact_value='CREATURE_TILE', args_count=1, until_exact_value='CREATURE')
        # Find the first token, following [CREATURE:DEER], that looks like [COLOR:6:0:0]
        deercolor = deertoken.getuntil(exact_value='COLOR', args_count=3, until_exact_value='CREATURE')
        if deertile and deercolor:
            # Change the token to look like [CREATURE_TILE:'d']
            deertile.args[0] = tile
            # Change the token to look like [COLOR:6:0:1]
            deercolor.args = color
            return pydwarf.success()
        else:
            return pydwarf.failure('Didn\'t find CREATURE_TILE and COLOR tokens as expected.')
    else:
        return pydwarf.failure('I couldn\'t find the deer token.')
Exemple #36
0
def nograzers(df):
    # Do the removing
    grazers = df.removeall('GRAZER')
    standardgrazers = df.removeall('STANDARD_GRAZER')
    
    # All done!
    if len(grazers) or len(standardgrazers):
        return pydwarf.success('Removed %d GRAZER and %d STANDARD_GRAZER tokens.' % (len(grazers), len(standardgrazers)))
    else:
        return pydwarf.failure('I found no grazer tokens to remove.')
Exemple #37
0
def noexotic(df):
    # Do the removing
    pets = df.all('PET_EXOTIC').each(lambda token: token.setvalue('PET'), none=True)
    mounts = df.all('MOUNT_EXOTIC').each(lambda token: token.setvalue('MOUNT'), none=True)
    
    # All done!
    if len(pets) or len(mounts):
        return pydwarf.success('Replaced %d PET_EXOTIC and %d MOUNT_EXOTIC tokens.' % (len(pets), len(mounts)))
    else:
        return pydwarf.failure('I found no PET_EXOTIC or MOUNT_EXOTIC tokens to replace.')
Exemple #38
0
def nograzers(df):
    # Do the removing
    grazers = df.removeall('GRAZER')
    standardgrazers = df.removeall('STANDARD_GRAZER')
    
    # All done!
    if len(grazers) or len(standardgrazers):
        return pydwarf.success('Removed %d GRAZER and %d STANDARD_GRAZER tokens.' % (len(grazers), len(standardgrazers)))
    else:
        return pydwarf.failure('I found no grazer tokens to remove.')
def noanimalmen(df):
    # Do the removing
    removed = [removedprop for removedprop in df.allobj('CREATURE').each(
        lambda token: token.removeselfandprops() if token.arg().endswith('_MAN') or token.getprop('APPLY_CREATURE_VARIATION:ANIMAL_PERSON') else None
    ) if removedprop]
    
    # All done!
    if removed:
        return pydwarf.success('Removed %d species of animal men.' % len(removed))
    else:
        return pydwarf.failure('Found no animal men to remove.')
def armourypack(dfraws, remove_entity_items=True, remove_attacks=('SCRATCH', 'BITE'), remove_attacks_from=('DWARF', 'HUMAN', 'ELF')):
    try:
        armouryraws = raws.dir(path=armourydir, log=pydwarf.log)
    except:
        return pydwarf.failure('Unable to load armoury raws.')
    
    additemstoraws(dfraws, armouryraws)
    additemstoents(dfraws, armouryraws, remove_entity_items)
    addreactions(dfraws, armouryraws)
    removeattacks(dfraws, remove_attacks, remove_attacks_from)
    
    return pydwarf.success()
def removeattacks(df, remove_attacks=('SCRATCH', 'BITE'), remove_attacks_from=('DWARF', 'HUMAN', 'ELF')):
    removed = 0
    for creature in df.allobj(type='CREATURE', id_in=remove_attacks_from):
        for attack in creature.allprop(exact_value='ATTACK', arg_in=((0, remove_attacks),)):
            pydwarf.log.debug('Removing attack %s from creature %s.' % (attack, creature))
            for token in attack.all(until_re_value='(?!ATTACK_).+'): token.remove()
            attack.remove()
            removed += 1
    if removed:
        return pydwarf.success('Removed %d attacks from %d creatures.' % (removed, len(remove_attacks_from)))
    else:
        return pydwarf.failure('Removed no attacks from creatures.')
Exemple #42
0
def flybears(df):
    # Get all bear creature tokens
    bears = df.allobj('CREATURE', re_id='BEAR_.+')
    
    # Add [FLIER] to each of them, immediately after the first CASTE:FEMALE token
    for bear in bears:
        bear.get('CASTE:FEMALE').add('FLIER')
        
    # All done!
    if len(bears):
        return pydwarf.success('Made %d bear species fliers.' % len(bears))
    else:
        return pydwarf.failure('Couldn\'t find any bears to make fliers.')
Exemple #43
0
def addtoentity(df, entities, tokens):
    if isinstance(entities, basestring): entities = (entities,)
    pydwarf.log.debug('Adding tokens to entities %s.' % ', '.join(str(ent) for ent in entities))
    entitytokens = df.allobj(type='ENTITY', id_in=entities)
    
    for entitytoken in entitytokens:
        entitytoken.addprop(tokens)
        if isinstance(tokens, raws.queryable): tokens = raws.helpers.copy(tokens) # TODO: What about other iterables containing token objects, e.g. lists and tuples?
        
    if len(entitytokens) != len(entities):
        return pydwarf.failure('Failed to add tokens to all given entities because only %d of %d exist.' % (len(entitytokens), len(entities)))
    else:
        return pydwarf.success('Added tokens to %d entities.' % len(entitytokens))
Exemple #44
0
def nograzers(raws):
    grazers = raws.all(exact_value='GRAZER')
    standardgrazers = raws.all('STANDARD_GRAZER')
    for grazer in grazers:
        grazer.remove()
    for grazer in standardgrazers:
        grazer.remove()
    if len(grazers) or len(standardgrazers):
        return pydwarf.success(
            'Removed %d GRAZER and %d STANDARD_GRAZER tokens.' %
            (len(grazers), len(standardgrazers)))
    else:
        return pydwarf.failure('I found no grazer tokens to replace.')
Exemple #45
0
def maxage(df,
           ages=default_ages,
           apply_default_age=None,
           output_needs_age=False):
    added = []
    modified = []

    # Handle each creature
    for creaturetoken in df.allobj('CREATURE'):
        creaturename = creaturetoken.args[0]
        maxage = creaturetoken.getprop('MAXAGE')

        # Creature is in the ages dict, give it the age specified
        if creaturename in ages:
            agetuple = ages.get(creaturename)
            if agetuple is not None:
                pydwarf.log.debug('Applying MAXAGE %s to %s...' %
                                  (agetuple, creaturetoken))
                if maxage:
                    modified.append(creaturename)
                    maxage.args = list(agetuple)
                else:
                    added.append(creaturename)
                    creaturetoken.addprop(
                        raws.token(value='MAXAGE', args=list(agetuple)))

        # Creature isn't in the ages dict, check about applying a default or simply outputting its existence
        elif (not maxage) and (output_needs_age or apply_default_age):
            props = creaturetoken.propdict()
            if not ('COPY_TAGS_FROM' in props or 'EQUIPMENT_WAGON' in props
                    or 'MEGABEAST' in props or 'DOES_NOT_EXIST' in props
                    or 'NOT_LIVING' in props):
                if apply_default_age is not None:
                    pydwarf.log.debug('Applying default MAXAGE %s to %s...' %
                                      (apply_default_age, creaturetoken))
                    creaturetoken.addprop(
                        raws.token(value='MAXAGE',
                                   args=list(apply_default_age)))
                    added.append(creaturename)
                else:
                    pydwarf.log.info('Creature %s has no MAXAGE.')

    # All done!
    pydwarf.log.debug('Modified MAXAGE tokens of creatures: %s.' % modified)
    pydwarf.log.debug('Added MAXAGE tokens to creatures: %s.' % added)
    if len(added) or len(modified):
        return pydwarf.success(
            'Added %d MAXAGE tokens and modified %d existing ones.' %
            (len(added), len(modified)))
    else:
        return pydwarf.failure('No MAXAGE tokens affected.')
def orientation(df, creatures=default_creatures, mode='hetero', lover_chance=default_lover_chance):
    if isinstance(mode, basestring):
        if mode not in mode_info: return pydwarf.failure('Invalid mode %s. Recognized modes are these: %s.' % (mode, ', '.join(mode_tokens.keys())))
        usemode = mode_info[mode]
    else:
        usemode = mode
    
    # Unpack variables for convenience
    disinterestsame, loversame, commitsame, disinterestother, loverother, commitother = usemode
    
    # Get tokens for all the specified creatures
    creatures = df.allobj(type='CREATURE', id_in=creatures)
    pydwarf.log.debug('Found %d applicable creatures.' % len(creatures))
    
    # Add tokens after [FEMALE] and [MALE] tokens
    added = 0
    for creature in creatures:
        pydwarf.log.debug('Applying ORIENTATION changes to %s.' % creature)
        
        # Remove any existing ORIENTATION tokens
        removetokens = creature.allprop(exact_value='ORIENTATION')
        if len(removetokens):
            pydwarf.log.debug('Removing %d existing ORIENTATION tokens from token %s.' % (len(removetokens), gendertoken))
            for removetoken in removetokens: removetoken.remove()
        
        # Add the new orientation tokens
        gendertokens = creature.allprop(value_in=('FEMALE', 'MALE'), args_count=0)
        for gendertoken in gendertokens:
            othergender = 'FEMALE' if gendertoken.value == 'MALE' else 'MALE'
            gendertoken.add(raws.token(value='ORIENTATION', args=[othergender, disinterestother, loverother, commitother]))
            gendertoken.add(raws.token(value='ORIENTATION', args=[gendertoken.value, disinterestsame, loversame, commitsame]))
            added += 1
    
    # All done!
    if added > 0:
        return pydwarf.success('Appended ORIENTATION tokens after %d gender tokens.' % added)
    else:
        return pydwarf.failure('Found no gender tokens to add ORIENTATION to.')
Exemple #47
0
def noexotic(raws):
    pets = raws.all('PET_EXOTIC')
    mounts = raws.all('MOUNT_EXOTIC')
    for token in pets:
        token.value = 'PET'
    for token in mounts:
        token.value = 'MOUNT'
    if len(pets) or len(mounts):
        return pydwarf.success(
            'Replaced %d PET_EXOTIC and %d MOUNT_EXOTIC tokens.' %
            (len(pets), len(mounts)))
    else:
        return pydwarf.failure(
            'I found no PET_EXOTIC or MOUNT_EXOTIC tokens to replace.')
def easypatch_file(df, file, collision_fails=True, replace=False, **kwargs):
    if replace or str(file) not in df:
        df.add(file, replace=replace)
        objects = file.allobj()
        response = pydwarf.urist.getfn('pineapple.utils.permitobjects')(
            df,
            objects = objects,
            **kwargs
        )
        return response
    elif collision_fails:
        return pydwarf.failure('Failed to add file because a file by the same name already exists in the dir.')
    else:
        return pydwarf.success('Didn\'t add the file because a file by the same name already exists in the dir.')
def microreduce(dfraws):
    mountain = dfraws.get('ENTITY:MOUNTAIN')
    if mountain:
        # Add files
        genericpath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'Microreduce', '%s.txt')
        for filename in ('building_macro_fantastic', 'item_macro_fantastic', 'reaction_macro_fantastic'):
            rfile = dfraws.addfile(path=genericpath % filename)
            # Add PERMITTED_BUILDING and PERMITTED_REACTION tokens to ENTITY:MOUNTAIN
            for building in rfile.all(re_value='BUILDING.*', args_count=1):
                mountain.add(raws.token(value='PERMITTED_BUILDING', args=[building.args[0]]))
            for reaction in rfile.all(exact_value='REACTION', args_count=1):
                mountain.add(raws.token(value='REACTION', args=[reaction.args[0]]))
        return pydwarf.success()
    else:
        return pydwarf.failure('Couldn\'t find ENTITY:MOUNTAIN.')
Exemple #50
0
def easypatch_file(df, file, collision_fails=True, replace=False, **kwargs):
    if replace or str(file) not in df:
        df.add(file, replace=replace)
        objects = file.allobj()
        response = pydwarf.urist.getfn('pineapple.utils.permitobjects')(
            df, objects=objects, **kwargs)
        return response
    elif collision_fails:
        return pydwarf.failure(
            'Failed to add file because a file by the same name already exists in the dir.'
        )
    else:
        return pydwarf.success(
            'Didn\'t add the file because a file by the same name already exists in the dir.'
        )
def armourypack(dfraws,
                remove_entity_items=True,
                remove_attacks=('SCRATCH', 'BITE'),
                remove_attacks_from=('DWARF', 'HUMAN', 'ELF')):
    try:
        armouryraws = raws.dir(path=armourydir, log=pydwarf.log)
    except:
        return pydwarf.failure('Unable to load armoury raws.')

    additemstoraws(dfraws, armouryraws)
    additemstoents(dfraws, armouryraws, remove_entity_items)
    addreactions(dfraws, armouryraws)
    removeattacks(dfraws, remove_attacks, remove_attacks_from)

    return pydwarf.success()
def greensteel(df, entities=default_entities):
    # Add greensteel raws
    try:
        df.read(path=greendir, log=pydwarf.log)
        return pydwarf.urist.getfn('pineapple.utils.addtoentity')(
            df,
            entities = entities,
            permitted_reaction = (
                'GREEN_STEEL_MAKING_ADAMANT_PINEAPPLE',
                'GREEN_STEEL_MAKING_ADMANTINE_PINEAPPLE'
            )
        )
    except:
        pydwarf.log.exception('Failed to add greensteel raws.')
        return pydwarf.failure()
Exemple #53
0
def subterraneanplants(df):
    # Get subterranean plants
    subplants = []
    for plant in df.allobj('PLANT'):
        if plant.getprop('BIOME:SUBTERRANEAN_WATER'):
            subplants.append(plant)
    if not len(subplants):
        return pydwarf.failure('Found no subterranean plants.')

    # Ensure each has all four seasons
    pydwarf.log.info('Found %d subterranean plants. Modifying...' %
                     len(subplants))
    modified = 0
    for subplant in subplants:
        seasontokens = subplant.allprop(value_in=seasons)
        if len(seasontokens) > 0 and len(seasontokens) < len(seasons):
            pydwarf.log.debug('Adding season tokens to %s...' % subplant)
            # First remove the existing tokens (To avoid making duplicates)
            for seasontoken in seasontokens:
                seasontoken.remove()
            # Then add all four anew
            for season in seasons:
                subplant.add(raws.token(value=season))
            modified += 1
        else:
            pydwarf.log.debug(
                'Plant %s either has no seasonal tokens or already has all of them, skipping.'
                % subplant)

    # All done
    if modified > 0:
        return pydwarf.success('Made %d subterranean plants grow year-round.' %
                               modified)
    else:
        return pydwarf.failure(
            'All subterranean plants already grew year-round.')
Exemple #54
0
def noanimalmen(df):
    # Do the removing
    removed = [
        removedprop for removedprop in df.allobj('CREATURE').each(
            lambda token: token.removeselfandprops() if (token.arg().endswith(
                '_MAN') or token.arg().endswith(' MAN') or token.getprop(
                    'APPLY_CREATURE_VARIATION:ANIMAL_PERSON')) else None)
        if removedprop
    ]

    # All done!
    if removed:
        return pydwarf.success('Removed %d species of animal men.' %
                               len(removed))
    else:
        return pydwarf.failure('Found no animal men to remove.')
Exemple #55
0
def metalitems(df, metals=default_metals, items=default_item_tokens):
    # Turn the item names into a list of tokens
    itemtokens = [raws.token(value=item) for item in items]

    # Apply to each metal
    affected = df.allobj(type='INORGANIC', id_in=metals).each(lambda token: (
        # Remove existing tokens first to prevent duplicates when adding
        token.removeallprop(value_in=items),
        # And now add the specified tokens
        token.addprop(raws.helpers.copytokens(itemtokens))))

    # All done!
    if affected:
        return pydwarf.success('Affected %d metals.' % len(affected))
    else:
        return pydwarf.failure('Affected no metals.')
def skillrust(df, creatures=default_creatures, rates=default_rates):
    failures = []

    # Handle each creature
    creaturetokens = df.allobj(type='CREATURE', id_in=creatures)
    for creaturetoken in creaturetokens:
        pydwarf.log.debug('Handling skill rust for %s.' % creaturetoken)

        # First see about editing existing skill tokens
        needsnew = True
        editedtotal = 0
        existingtokens = creaturetoken.allprop(value_in=('SKILL_RATE',
                                                         'SKILL_RUST_RATE',
                                                         'SKILL_RATES',
                                                         'SKILL_RUST_RATES'))
        for existingtoken in existingtokens:
            pydwarf.log.debug('Modifying arguments for existing token %s.' %
                              existingtoken)
            edited = False
            if existingtoken.value in ('SKILL_RATES', 'SKILL_RUST_RATES'):
                needsnew = False
            editedtoken = edittoken(existingtoken, rates)
            editedtotal += editedtoken
            pydwarf.log.debug((
                'Modified arguments for token.') if editedtoken else (
                    'Token already has no skill rust.'))

        # Add a new one if no token affecting all skills was found
        if needsnew:
            pydwarf.log.debug('Adding new SKILL_RUST_RATES token.')
            creaturetoken.addprop('SKILL_RUST_RATES:NONE:NONE:NONE')

        # Creature already had no skill rust; consider this a failure
        elif not editedtotal:
            pydwarf.log.error('%s already has no skill rust.' % creaturetoken)
            failures.append(creaturetoken)

    # All done!
    failurecount = len(failures) + len(creatures) - len(creaturetokens)
    if failurecount == 0:
        return pydwarf.success('Removed skill rust from %d creatures.' %
                               len(creatures))
    else:
        return pydwarf.failure(
            'Failed to remove skill rust from %d creatures.' % failurecount)
def nogiantanimals(df):
    # Do the removing
    removed = [
        removedprop for removedprop
        in df.allobj('CREATURE').each(lambda token: (token.removeselfandprops(
        ) if (token.arg().startswith('GIANT_') or token.arg(
        ).endswith(', GIANT') or token.arg().endswith('_GIANT') or token.arg(
        ).startswith('GIANT ') or token.arg().startswith('GIGANTIC ') or token.
              getprop('APPLY_CREATURE_VARIATION:GIANT')) else None))
        if removedprop
    ]

    # All done!
    if removed:
        return pydwarf.success('Removed %d species of giant animals.' %
                               len(removed))
    else:
        return pydwarf.failure('Found no giant animals to remove.')