def _getDisplayParams(cls, curEq, compareEq, eqsRange, param): curShell = vehicles.getItemByCompactDescr(getattr(curEq, param)) compShell = vehicles.getItemByCompactDescr(getattr(compareEq, param)) shellsRange = (vehicles.getItemByCompactDescr(getattr(eq, param)) for eq in eqsRange) curValue = curShell.stun.stunDuration if curShell.hasStun else 0 compValue = compShell.stun.stunDuration if compShell.hasStun else 0 return (curValue, compValue - curValue, max(((shell.stun.stunDuration if shell.hasStun else 0) for shell in shellsRange)))
def __init__(self, strCompactDescr=None, component=None, vehicleCD='', vehicleType=None): super(Outfit, self).__init__(strCompactDescr) self._containers = {} self._vehicleCD = vehicleCD if strCompactDescr is not None and component is not None: raise SoftException("'strCompactDescr' and 'component' arguments are mutually exclusive!") if strCompactDescr: component = parseOutfitDescr(strCompactDescr) elif component is None: component = CustomizationOutfit() self._id = component.styleId self.__styleProgressionLevel = component.styleProgressionLevel self.__styleSerialNumber = component.serial_number self._styleDescr = None if self._id: intCD = makeIntCompactDescrByID('customizationItem', CustomizationType.STYLE, self._id) if not IS_EDITOR: self._styleDescr = getItemByCompactDescr(intCD) else: from items.vehicles import g_cache if g_cache.customization20(createNew=False): self._styleDescr = getItemByCompactDescr(intCD) self._construct(vehicleType=vehicleType) for container in self._containers.itervalues(): container.unpack(component) self.__itemsCounter = None self.invalidate() return
def bind(self, componentIdx, componentSlot): params = self._data[componentIdx] slotIdx = len(params) if componentIdx in Insignia.Indexes.ALL: if IS_EDITOR: defaultParams = _TextureParams('', '', False) item = items.vehicles.g_cache.customization20().insignias.get(componentSlot.edResourceId) stickerParam = defaultParams if item is None else self._convertToInsignia(item) else: container = self._outfit.getContainer(TankPartIndexes.GUN) slot = container.slotFor(GUI_ITEM_TYPE.INSIGNIA) intCD = slot.getItemCD(slotIdx) if intCD: item = getItemByCompactDescr(intCD) stickerParam = self._convertToInsignia(item) self._useCustomInsignia = True else: stickerParam = self._getDefaultParams() else: container = self._outfit.getContainer(componentIdx) slot = container.slotFor(GUI_ITEM_TYPE.INSIGNIA) intCD = slot.getItemCD(slotIdx) if intCD: item = getItemByCompactDescr(intCD) stickerParam = self._convertToCounter(item) self._useOldInsignia = False else: stickerParam = None params.append(_StickerSlotPair(componentSlot, stickerParam)) return
def bind(self, componentIdx, componentSlot): params = self._data[componentIdx] slotIdx = len(params) if componentIdx in Insignia.Indexes.ALL: container = self._outfit.getContainer(TankPartIndexes.GUN) slot = container.slotFor(GUI_ITEM_TYPE.INSIGNIA) intCD = slot.getItemCD(slotIdx) if intCD: item = getItemByCompactDescr(intCD) stickerParam = self._convertToInsignia(item) self._useCustomInsignia = True else: stickerParam = self._getDefaultParams() else: container = self._outfit.getContainer(componentIdx) slot = container.slotFor(GUI_ITEM_TYPE.INSIGNIA) intCD = slot.getItemCD(slotIdx) if intCD: item = getItemByCompactDescr(intCD) stickerParam = self._convertToCounter(item) self._useOldInsignia = False else: stickerParam = None params.append(_StickerSlotPair(componentSlot, stickerParam)) return
def __validateInvItem(self, itemTypeID, errorCode): for intCompactDescr, itemData in self.itemsCache.items.inventory.getItemsData( itemTypeID).iteritems(): try: vehicles.getItemByCompactDescr(abs(intCompactDescr)) except Exception as e: raise ValidateException( e.message, errorCode, self.__packItemData(itemTypeID, itemData))
def getRepaint(outfit, containerId, vDesc): enabled = False quality = fading = 0.0 overlapMetallic = overlapGloss = None nationID = vDesc.type.customizationNationID colorId = vDesc.type.baseColorID defaultColor = 0 if items.vehicles.g_cache.customization20(createNew=False): defaultColors = items.vehicles.g_cache.customization20().defaultColors defaultColor = defaultColors[nationID][colorId] intCD = outfit.misc.slotFor(GUI_ITEM_TYPE.MODIFICATION).getItemCD() if intCD: mod = getItemByCompactDescr(intCD) enabled = True quality = mod.getEffectValue(ModificationType.PAINT_AGE, quality) fading = mod.getEffectValue(ModificationType.PAINT_FADING, fading) overlapMetallic = mod.getEffectValue(ModificationType.METALLIC, overlapMetallic) overlapGloss = mod.getEffectValue(ModificationType.GLOSS, overlapGloss) container = outfit.getContainer(containerId) paintSlot = container.slotFor(GUI_ITEM_TYPE.PAINT) capacity = paintSlot.capacity() camoSlot = container.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE) if camoSlot is not None: if camoSlot.getItemCD(): enabled = True colors = [defaultColor] * capacity metallics = [overlapMetallic or DEFAULT_METALLIC] * (capacity + 1) glosses = [overlapGloss or DEFAULT_GLOSS] * (capacity + 1) for idx in range(capacity): intCD = paintSlot.getItemCD(idx) if intCD: paint = getItemByCompactDescr(intCD) enabled = True colors[idx] = paint.color metallics[idx] = overlapMetallic or paint.metallic glosses[idx] = overlapGloss or paint.gloss if not (containerId == TankPartIndexes.GUN and idx == C11N_MASK_REGION): colors[idx] = colors[0] metallics[idx] = overlapMetallic or metallics[0] glosses[idx] = overlapGloss or glosses[0] colors = tuple(colors) metallics = tuple(metallics) glosses = tuple(glosses) return RepaintParams(enabled, defaultColor, colors, metallics, glosses, fading, quality) if enabled else RepaintParams( enabled, defaultColor)
def _getParamValue(cls, curEq, param): curValue = 0 shellID = super(NestedShellStunValuesMixin, cls)._getParamValue(curEq, param) curShell = vehicles.getItemByCompactDescr(shellID) if curShell: curValue = curShell.stun.stunDuration if curShell.hasStun else 0 return _getFormattedNum(curValue)
def createCustomization(self, intCompactDescr, proxy=None): """ Creates customization items by the given arguments. :param intCompactDescr: item int compact descriptor :param proxy: instance of ItemsRequester :return: an instance of one of customizations """ descriptor = vehicles.getItemByCompactDescr(intCompactDescr) if descriptor.itemType == CustomizationType.CAMOUFLAGE: cls = Camouflage elif descriptor.itemType == CustomizationType.PAINT: cls = Paint elif descriptor.itemType == CustomizationType.MODIFICATION: cls = Modification elif descriptor.itemType == CustomizationType.STYLE: cls = Style elif descriptor.itemType == CustomizationType.DECAL: if descriptor.type == DecalType.EMBLEM: cls = Emblem elif descriptor.type == DecalType.INSCRIPTION: cls = Inscription else: LOG_WARNING('Unknown decal type', descriptor.type) cls = Decal else: LOG_WARNING('Unknown customization type', descriptor.itemType) cls = Customization return cls(intCompactDescr, proxy)
def __init__(self, strCompactDescr=None, component=None, vehicleCD='', vehicleType=None): super(Outfit, self).__init__(strCompactDescr) self._containers = {} self._vehicleCD = vehicleCD if strCompactDescr is not None and component is not None: raise SoftException( "'strCompactDescr' and 'component' arguments are mutually exclusive!" ) if strCompactDescr: component = parseOutfitDescr(strCompactDescr) elif component is None: component = CustomizationOutfit() self._id = component.styleId if self._id: intCD = makeIntCompactDescrByID('customizationItem', CustomizationType.STYLE, self._id) self._styleDescr = getItemByCompactDescr(intCD) else: self._styleDescr = None self._construct(vehicleType=vehicleType) for container in self._containers.itervalues(): container.unpack(component) self.__itemsCounter = None self.invalidate() return
def getItemDescrByCompactDescr(compDescr): itemTypeID, _, _ = vehicles.parseIntCompactDescr(compDescr) if itemTypeID in vehicles.VEHICLE_ITEM_TYPES: descr = vehicles.getItemByCompactDescr(compDescr) else: descr = tankmen.getItemByCompactDescr(compDescr) return descr
def createCustomization(self, intCompactDescr, proxy=None): descriptor = vehicles.getItemByCompactDescr(intCompactDescr) if descriptor.itemType == CustomizationType.CAMOUFLAGE: cls = Camouflage elif descriptor.itemType == CustomizationType.PAINT: cls = Paint elif descriptor.itemType == CustomizationType.MODIFICATION: cls = Modification elif descriptor.itemType == CustomizationType.STYLE: cls = Style elif descriptor.itemType == CustomizationType.DECAL: if descriptor.type == DecalType.EMBLEM: cls = Emblem elif descriptor.type == DecalType.INSCRIPTION: cls = Inscription else: LOG_WARNING('Unknown decal type', descriptor.type) cls = Decal elif descriptor.itemType == CustomizationType.PERSONAL_NUMBER: cls = PersonalNumber elif descriptor.itemType == CustomizationType.PROJECTION_DECAL: cls = ProjectionDecal elif descriptor.itemType == CustomizationType.INSIGNIA: cls = Insignia elif descriptor.itemType == CustomizationType.SEQUENCE: cls = Sequence elif descriptor.itemType == CustomizationType.ATTACHMENT: cls = Attachment else: LOG_WARNING('Unknown customization type', descriptor.itemType) cls = Customization return cls(intCompactDescr, proxy)
def __init__(self, strCompactDescr=None, isEnabled=False, isInstalled=False, proxy=None): super(Outfit, self).__init__(strCompactDescr) self._containers = {} if strCompactDescr: component = parseCompDescr(strCompactDescr) else: component = CustomizationOutfit() self._id = component.styleId if self._id: intCD = makeIntCompactDescrByID('customizationItem', CustomizationType.STYLE, self._id) self._styleDescr = getItemByCompactDescr(intCD) else: self._styleDescr = None self._isEnabled = isEnabled self._isInstalled = isInstalled for container in scaffold(): container.unpack(component, proxy) self._containers[container.getAreaID()] = container self.invalidate() return
def getFormattedParamsList(descriptor, parameters, excludeRelative=False): if vehicles.isVehicleDescr(descriptor): compactDescr = descriptor.type.compactDescr else: compactDescr = descriptor.compactDescr itemTypeIdx = getTypeOfCompactDescr(compactDescr) if itemTypeIdx == ITEM_TYPES.equipment: eqDescr = vehicles.getItemByCompactDescr(compactDescr) paramsList = ITEMS_PARAMS_LIST[itemTypeIdx].get(type(eqDescr), []) else: paramsList = ITEMS_PARAMS_LIST[itemTypeIdx] params = [] for paramName in paramsList: if excludeRelative and isRelativeParameter(paramName): continue paramValue = parameters.get(paramName) if paramValue: fmtValue = formatParameter(paramName, paramValue) if fmtValue: if paramName == 'autoReloadTime' and descriptor.gun.autoreloadHasBoost: paramName = 'autoReloadTimeBoost' elif paramName == CHASSIS_REPAIR_TIME and descriptor.isTrackWithinTrack: paramName = CHASSIS_REPAIR_TIME_YOH params.append((paramName, fmtValue)) return params
def getCamo(appearance, outfit, containerId, vDesc, descId, isDamaged, default=None): result = default if not outfit: return result else: container = outfit.getContainer(containerId) slot = container.slotFor(GUI_ITEM_TYPE.CAMOUFLAGE) if not slot: return result intCD = slot.getItemCD() if intCD: camouflage = getItemByCompactDescr(intCD) component = slot.getComponent() try: palette = camouflage.palettes[component.palette] except IndexError: palette = camouflage.palettes[0] weights = Math.Vector4(*[ (c >> 24) / 255.0 for c in palette ]) if isDamaged: weights *= _DEAD_VEH_WEIGHT_COEFF vehPartCompDesc = getattr(vDesc, descId, None) if not vehPartCompDesc: return result area = vehPartCompDesc.customizableVehicleAreas.get(lower(CustomizationTypeNames[CustomizationType.CAMOUFLAGE]), (0, None))[0] if not area: return result tiling, exclusionMap = processTiling(appearance, vDesc, descId, camouflage, component) camoAngle = camouflage.rotation[descId] result = CamoParams(camouflage.texture, exclusionMap or '', tiling, camoAngle, weights, palette[0], palette[1], palette[2], palette[3]) return result
def getGenericProjectionDecals(outfit, vehDesc): decalsParams = [] style = outfit.style model = style.modelsSet if style is not None and style.modelsSet else SLOT_DEFAULT_ALLOWED_MODEL for slotParams in __vehicleSlotsByType( vehDesc, SLOT_TYPE_NAMES.FIXED_PROJECTION_DECAL): if model in slotParams.compatibleModels: if IS_EDITOR and (slotParams.edResourceId <= 0 or not slotParams.slotWrapper.canDraw): continue fixedDecalParams = __getFixedProjectionDecalParams(slotParams) decalsParams.append(fixedDecalParams) if not IS_EDITOR: if decalsParams: return decalsParams slotsByIdMap, slotsByTagMap = __createVehSlotsMaps(vehDesc) projectionDecalsMultiSlot = outfit.misc.slotFor( GUI_ITEM_TYPE.PROJECTION_DECAL) if style is not None: succeeded = _matchTaggedProjectionDecalsToSlots( projectionDecalsMultiSlot, slotsByTagMap) if not succeeded: _logger.error( 'Failed to match tagged projection decals of style: %(styleId)s to vehicle: %(vehName)s slots.', { 'styleId': outfit.id, 'vehName': vehDesc.type.name }) return decalsParams projectionDecalsMultiSlot.sortByTags(slotsByIdMap) outfit.invalidateItemsCounter() for idx in projectionDecalsMultiSlot.order(): slotData = projectionDecalsMultiSlot.getSlotData(idx) if slotData.isEmpty(): continue item = getItemByCompactDescr(slotData.intCD) component = slotData.component slotId = component.slotId if slotId != ProjectionDecalPacker.STYLED_SLOT_ID: if slotId not in slotsByIdMap: _logger.error( 'Projection Decal slot mismatch. SlotId: %(slotId)s; Vehicle: %(vehName)s', { 'slotId': slotId, 'vehName': vehDesc.type.name }) continue slotParams = slotsByIdMap[slotId] elif component.tags: continue else: slotParams = None decalParams = __getProjectionDecalParams(vehDesc, item, component, slotParams) if decalParams is not None: decalsParams.append(decalParams) return decalsParams
def __getFixedProjectionDecalParams(slotParams): intCD = makeIntCompactDescrByID('customizationItem', CustomizationType.PROJECTION_DECAL, slotParams.itemId) item = getItemByCompactDescr(intCD) tintColor = __getProjectionDecalTintColor() mirroredHorizontally = slotParams.options & Options.MIRRORED_HORIZONTALLY mirroredVertically = slotParams.options & Options.MIRRORED_VERTICALLY params = ProjectionDecalGenericParams(tintColor=tintColor, position=Math.Vector3(slotParams.position), rotation=Math.Vector3(slotParams.rotation), scale=Math.Vector3(slotParams.scale), decalMap=item.texture, glossDecalMap=item.glossTexture, applyAreas=slotParams.showOn, clipAngle=slotParams.clipAngle, mirroredHorizontally=mirroredHorizontally, mirroredVertically=mirroredVertically, doubleSided=slotParams.doubleSided, scaleBySlotSize=True) return params
def __validateInvItem(self, itemTypeID, errorCode): for intCompactDescr, itemData in self.itemsCache.items.inventory.getCacheValue(itemTypeID, {}).iteritems(): try: item = vehicles.getItemByCompactDescr(abs(intCompactDescr)) if item.typeID != itemTypeID: raise SoftException('Expected {} to be of type {}, got {} instead'.format(intCompactDescr, itemTypeID, item.typeID)) except Exception as e: raise ValidateException(e.message, errorCode, _packItemData(itemTypeID, itemData))
def pack(slot, component): for region, intCD, subcomp in slot.items(): item = getItemByCompactDescr(intCD) component.camouflages.append( CamouflageComponent(id=item.id, patternSize=subcomp.patternSize, palette=subcomp.palette, appliedTo=region))
def __getItemsDescriptors(self, itemType, idx): iterator = CACHE_ITERATORS[itemType](idx) if itemType == ITEM_TYPES.vehicle: return [vehicles.VehicleDescr(typeID=(idx, cd)) for cd in iterator] return [ vehicles.getItemByCompactDescr(data.compactDescr) for data in iterator ]
def getModelAnimatorsPrereqs(outfit, spaceId): multiSlot = outfit.misc.slotFor(GUI_ITEM_TYPE.SEQUENCE) prereqs = [] for _, intCD, _ in multiSlot.items(): item = getItemByCompactDescr(intCD) prereqs.append(AnimationSequence.Loader(item.sequenceName, spaceId)) return prereqs
def pack(slot, component): for _, intCD, subcomp in slot.items(): item = getItemByCompactDescr(intCD) component.attachments.append( AttachmentComponent(id=item.id, slotId=subcomp.slotId, position=subcomp.position, rotation=subcomp.rotation))
def pack(slot, component): for region, intCD, subcomp in slot.items( (CustomizationType.PERSONAL_NUMBER, )): item = getItemByCompactDescr(intCD) component.personal_numbers.append( PersonalNumberComponent(id=item.id, number=subcomp.number, appliedTo=region))
def _checkSlotCompatibility(self, parsedCompDescr=None, descr=None): res, _ = super(EpicEquipmentSlot, self)._checkSlotCompatibility(parsedCompDescr, descr) if not res: return (res, _) item = descr or getItemByCompactDescr(parsedCompDescr) return (self.tags.intersection(self.JOINING_TAGS).issubset( getattr(item, 'tags', ())), '')
def createEquipment(self, intCompactDescr, proxy=None, isBoughtForCredits=False): descriptor = vehicles.getItemByCompactDescr(intCompactDescr) if descriptor.equipmentType == EQUIPMENT_TYPES.battleBoosters: cls = BattleBooster elif descriptor.equipmentType == EQUIPMENT_TYPES.battleAbilities: cls = BattleAbility else: cls = Equipment return cls(intCompactDescr, proxy, isBoughtForCredits)
def getOrderedShellsLayout(self): result = [] for intCD in self._order: descriptor = vehicles.getItemByCompactDescr(intCD) quantity, quantityInClip = self.__ammo[intCD] result.append((intCD, descriptor, quantity, quantityInClip, self.__gunSettings)) return result
def customizationDisplayType(self): if self._styleDescr: return self._styleDescr.customizationDisplayType itemsCustomizationDisplayType = [ getItemByCompactDescr(intCD).customizationDisplayType for intCD in self.items() ] return max( itemsCustomizationDisplayType ) if itemsCustomizationDisplayType else CustomizationDisplayType.HISTORICAL
def getEquipmentParameters(eqpDescr): params = dict() eqDescrType = type(eqpDescr) if eqDescrType is artefacts.RageArtillery: shellDescr = vehicles.getItemByCompactDescr(eqpDescr.shellCompactDescr) params.update({'damage': (shellDescr.damage[0],) * 2, 'piercingPower': eqpDescr.piercingPower, 'caliber': shellDescr.caliber, 'shotsNumberRange': eqpDescr.shotsNumber, 'areaRadius': eqpDescr.areaRadius, 'artDelayRange': eqpDescr.delay}) elif eqDescrType is artefacts.RageBomber: shellDescr = vehicles.getItemByCompactDescr(eqpDescr.shellCompactDescr) params.update({'bombDamage': (shellDescr.damage[0],) * 2, 'piercingPower': eqpDescr.piercingPower, 'bombsNumberRange': eqpDescr.bombsNumber, 'areaSquare': eqpDescr.areaLength * eqpDescr.areaWidth, 'flyDelayRange': eqpDescr.delay}) return params
def items(self, customizationTypes=None): if customizationTypes: for idx, pair in self._items.iteritems(): item = getItemByCompactDescr(pair.intCD) if item.itemType in customizationTypes: yield (self._regions[idx], pair.intCD, pair.component) else: for idx, pair in self._items.iteritems(): yield (self._regions[idx], pair.intCD, pair.component)
def getEquipmentParameters(eqpDescr): params = dict() eqDescrType = type(eqpDescr) if eqDescrType is artefacts.RageArtillery: shellDescr = vehicles.getItemByCompactDescr(eqpDescr.shellCompactDescr) params.update({ 'damage': (shellDescr.damage[0], ) * 2, 'piercingPower': eqpDescr.piercingPower, 'caliber': shellDescr.caliber, 'shotsNumberRange': eqpDescr.shotsNumber, 'areaRadius': eqpDescr.areaRadius, 'artDelayRange': eqpDescr.delay }) elif eqDescrType is artefacts.RageBomber: shellDescr = vehicles.getItemByCompactDescr(eqpDescr.shellCompactDescr) params.update({ 'bombDamage': (shellDescr.damage[0], ) * 2, 'piercingPower': eqpDescr.piercingPower, 'bombsNumberRange': eqpDescr.bombsNumber, 'areaSquare': eqpDescr.areaLength * eqpDescr.areaWidth, 'flyDelayRange': eqpDescr.delay }) elif eqDescrType is artefacts.AttackArtilleryFortEquipment: params.update({ 'maxDamage': eqpDescr.maxDamage, 'commonDelay': eqpDescr.delay, 'areaRadius': eqpDescr.areaRadius, 'duration': eqpDescr.duration }) elif eqDescrType in (artefacts.FortConsumableInspire, artefacts.ConsumableInspire): params.update({ 'crewRolesFactor': max(eqpDescr.increaseFactors['crewRolesFactor'] * 100 - 100, 0), 'inactivationDelay': eqpDescr.inactivationDelay, 'commonAreaRadius': eqpDescr.radius, 'duration': eqpDescr.duration }) return params
def getAttachmentParams(slotParams, slotData, idx): item = getItemByCompactDescr(slotData.intCD) return AttachmentParams( transform=__createTransform(slotParams, slotData), attachNode=slotParams.attachNode, modelName=item.modelName, sequenceId=item.sequenceId, attachmentLogic=item.attachmentLogic, initialVisibility=item.initialVisibility, partNodeAlias='attachment' + str(idx) if item.attachmentLogic != 'prefab' else None)