def attach(self, compoundModel, isDamaged, showDamageStickers):
for componentName, attachNodeName in VehicleStickers.COMPONENT_NAMES:
idx = TankPartNames.getIdx(componentName)
node = compoundModel.node(attachNodeName)
if node is None:
continue
geometryLink = compoundModel.getPartGeometryLink(idx)
componentStickers = self.__stickers[componentName]
componentStickers.stickers.attachStickers(geometryLink, node, isDamaged)
if showDamageStickers:
for damageSticker in componentStickers.damageStickers.itervalues():
if damageSticker.handle is not None:
componentStickers.stickers.delDamageSticker(damageSticker.handle)
damageSticker.handle = None
LOG_WARNING('Adding %s damage sticker to occupied slot' % componentName)
damageSticker.handle = componentStickers.stickers.addDamageSticker(damageSticker.stickerID, damageSticker.rayStart, damageSticker.rayEnd)
if self.__animateGunInsignia:
gunNode = compoundModel.node(TankNodeNames.GUN_INCLINATION) if isDamaged else compoundModel.node(VehicleStickers.__INSIGNIA_NODE_NAME)
else:
gunNode = compoundModel.node(TankNodeNames.GUN_INCLINATION)
if gunNode is None:
return
else:
gunGeometry = compoundModel.getPartGeometryLink(TankPartIndexes.GUN)
self.__stickers['gunInsignia'].stickers.attachStickers(gunGeometry, gunNode, isDamaged)
return
def __setupModel(self, buildIdx):
self.__assembleModel()
matrix = math_utils.createSRTMatrix(Math.Vector3(1.0, 1.0, 1.0), Math.Vector3(self.__vEntity.yaw, self.__vEntity.pitch, self.__vEntity.roll), self.__vEntity.position)
self.__vEntity.model.matrix = matrix
self.__doFinalSetup(buildIdx)
self.__vEntity.typeDescriptor = self.__vDesc
typeDescr = self.__vDesc
wheelConfig = typeDescr.chassis.generalWheelsAnimatorConfig
if self.wheelsAnimator is not None and wheelConfig is not None:
self.wheelsAnimator.createCollision(wheelConfig, self.collisions)
gunColBox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.GUN) + 3)
center = 0.5 * (gunColBox[1] - gunColBox[0])
gunoffset = Math.Matrix()
gunoffset.setTranslate((0.0, 0.0, center.z + gunColBox[0].z))
gunNode = self.__getGunNode()
gunLink = math_utils.MatrixProviders.product(gunoffset, gunNode)
collisionData = ((TankPartNames.getIdx(TankPartNames.CHASSIS), self.__vEntity.model.matrix),
(TankPartNames.getIdx(TankPartNames.HULL), self.__vEntity.model.node(TankPartNames.HULL)),
(TankPartNames.getIdx(TankPartNames.TURRET), self.__vEntity.model.node(TankPartNames.TURRET)),
(TankPartNames.getIdx(TankPartNames.GUN), gunNode))
self.collisions.connect(self.__vEntity.id, ColliderTypes.VEHICLE_COLLIDER, collisionData)
collisionData = ((TankPartNames.getIdx(TankPartNames.GUN) + 1, self.__vEntity.model.node(TankPartNames.HULL)), (TankPartNames.getIdx(TankPartNames.GUN) + 2, self.__vEntity.model.node(TankPartNames.TURRET)), (TankPartNames.getIdx(TankPartNames.GUN) + 3, gunLink))
self.collisions.connect(self.__vEntity.id, self._getColliderType(), collisionData)
self._reloadColliderType(self.__vEntity.state)
self.__reloadShadowManagerTarget(self.__vEntity.state)
return
def applyPlayerCache(outfit, vehName, seasonCache):
itemsCache = dependency.instance(IItemsCache)
for itemTypeName in seasonCache.keys():
if itemTypeName not in ('paint', 'modification', 'emblem',
'inscription'):
if itemTypeName != 'camo':
print '%s: invalid item type in outfit cache for %s:' % (
g_config.ID, vehName), itemTypeName
del seasonCache[itemTypeName]
continue
itemDB = items.vehicles.g_cache.customization20().itemTypes[
C11N_ITEM_TYPE_MAP[GUI_ITEM_TYPE_INDICES[itemTypeName]]]
for areaName in seasonCache[itemTypeName].keys():
if itemTypeName == 'modification':
if areaName != 'misc':
print g_config.ID + ': wrong area name for', vehName, 'modification:', areaName
del seasonCache[itemTypeName][areaName]
continue
else:
areaId = Area.MISC
else:
try:
areaId = TankPartNames.getIdx(areaName)
except Exception as e:
print g_config.ID + ': exception while reading outfit cache for', vehName, 'in', areaName + ':', e.message
continue
slot = outfit.getContainer(areaId).slotFor(
GUI_ITEM_TYPE_INDICES[itemTypeName])
for regionIdx in seasonCache[itemTypeName][areaName].keys():
itemID = seasonCache[itemTypeName][areaName][regionIdx]
if not itemID:
try:
slot.remove(int(regionIdx))
except KeyError: # a paint is being deleted while not applied at all. possible change after last cache
del seasonCache[itemTypeName][areaName][
regionIdx] # so we remove an obsolete key
continue
if itemID not in itemDB:
print '%s: wrong item ID for %s, idx %s:' % (
g_config.ID, areaName, regionIdx), itemID
del seasonCache[itemTypeName][areaName][regionIdx]
continue
intCD = itemDB[itemID].compactDescr
if itemsCache.items.isSynced():
item = itemsCache.items.getItemByCD(intCD)
else:
item = itemsCache.items.itemsFactory.createCustomization(
intCD)
slot.set(item, int(regionIdx))
if not seasonCache[itemTypeName][areaName]:
del seasonCache[itemTypeName][areaName]
outfit.invalidate()
def __startBuild(self, vDesc, vState):
self.__curBuildInd += 1
self.__vState = vState
self.__resources = {}
self.__vehicleStickers = None
cfg = hangarCFG()
if vState == 'undamaged':
self.__currentEmblemsAlpha = cfg['emblems_alpha_undamaged']
self.__isVehicleDestroyed = False
else:
self.__currentEmblemsAlpha = cfg['emblems_alpha_damaged']
self.__isVehicleDestroyed = True
self.__vDesc = vDesc
resources = camouflages.getCamoPrereqs(self.__outfit, vDesc)
splineDesc = vDesc.chassis.splineDesc
if splineDesc is not None:
resources.append(splineDesc.segmentModelLeft)
resources.append(splineDesc.segmentModelRight)
if splineDesc.leftDesc is not None:
resources.append(splineDesc.leftDesc)
if splineDesc.rightDesc is not None:
resources.append(splineDesc.rightDesc)
if splineDesc.segment2ModelLeft is not None:
resources.append(splineDesc.segment2ModelLeft)
if splineDesc.segment2ModelRight is not None:
resources.append(splineDesc.segment2ModelRight)
from vehicle_systems import model_assembler
resources.append(model_assembler.prepareCompoundAssembler(self.__vDesc, ModelsSetParams(self.__outfit.modelsSet, self.__vState), self.__spaceId))
g_eventBus.handleEvent(CameraRelatedEvents(CameraRelatedEvents.VEHICLE_LOADING, ctx={'started': True,
'vEntityId': self.__vEntity.id}), scope=EVENT_BUS_SCOPE.DEFAULT)
cfg = hangarCFG()
gunScale = Math.Vector3(1.0, 1.0, 1.1)
capsuleScale = Math.Vector3(1.5, 1.5, 1.5)
loadedGunScale = cfg.get('cam_capsule_gun_scale', gunScale)
if loadedGunScale is not None:
gunScale = loadedGunScale
loadedCapsuleScale = cfg.get('cam_capsule_scale', capsuleScale)
if loadedCapsuleScale is not None:
capsuleScale = loadedCapsuleScale
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS), vDesc.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL), vDesc.hull.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.TURRET), vDesc.turret.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.GUN), vDesc.gun.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.GUN) + 1, vDesc.hull.hitTester.bspModelName, capsuleScale),
(TankPartNames.getIdx(TankPartNames.GUN) + 2, vDesc.turret.hitTester.bspModelName, capsuleScale),
(TankPartNames.getIdx(TankPartNames.GUN) + 3, vDesc.gun.hitTester.bspModelName, gunScale))
collisionAssembler = BigWorld.CollisionAssembler(bspModels, self.__spaceId)
resources.append(collisionAssembler)
physicalTracksBuilders = vDesc.chassis.physicalTracks
for name, builder in physicalTracksBuilders.iteritems():
resources.append(builder.createLoader('{0}PhysicalTrack'.format(name)))
BigWorld.loadResourceListBG(tuple(resources), makeCallbackWeak(self.__onResourcesLoaded, self.__curBuildInd))
return
def start(self, prereqs=None):
self.collisions = prereqs['collisionAssembler']
self.__typeDesc.chassis.hitTester.bbox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.CHASSIS))
self.__typeDesc.hull.hitTester.bbox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.HULL))
self.__typeDesc.turret.hitTester.bbox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.TURRET))
self.__typeDesc.gun.hitTester.bbox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.GUN))
self.__compoundModel = prereqs[self.__typeDesc.name]
self.__boundEffects = bound_effects.ModelBoundEffects(self.__compoundModel)
isCurrentModelDamaged = self.__currentDamageState.isCurrentModelDamaged
fashions = camouflages.prepareFashions(isCurrentModelDamaged)
if not isCurrentModelDamaged:
model_assembler.setupTracksFashion(self.__typeDesc, fashions.chassis)
self.__setFashions(fashions, self.__isTurretDetached)
self.__setupModels()
if not isCurrentModelDamaged:
self.__splineTracks = model_assembler.setupSplineTracks(self.__fashion, self.__typeDesc, self.__compoundModel, prereqs)
self.crashedTracksController = CrashedTrackController(self.__typeDesc, self.__fashion)
else:
self.__trackScrollCtl = None
if self.__currentDamageState.effect is not None:
self.__playEffect(self.__currentDamageState.effect, SpecialKeyPointNames.STATIC)
self.__chassisDecal.create()
return
def attach(self,
compoundModel,
isDamaged,
showDamageStickers,
isDetachedTurret=False):
for componentName, attachNodeName in self.__componentNames:
idx = DetachedTurretPartNames.getIdx(
componentName) if isDetachedTurret else TankPartNames.getIdx(
componentName)
node = compoundModel.node(attachNodeName)
if node is None:
continue
if idx is None:
node = compoundModel.node(componentName + (
'_normal' if not isDamaged else '_destroyed'))
idx = compoundModel.findPartHandleByNode(node)
geometryLink = compoundModel.getPartGeometryLink(idx)
componentStickers = self.__stickers[componentName]
componentStickers.stickers.attachStickers(geometryLink, node,
isDamaged)
if showDamageStickers:
for damageSticker in componentStickers.damageStickers.itervalues(
):
if damageSticker.handle is not None:
componentStickers.stickers.delDamageSticker(
damageSticker.handle)
damageSticker.handle = None
LOG_WARNING(
'Adding %s damage sticker to occupied slot' %
componentName)
damageSticker.handle = componentStickers.stickers.addDamageSticker(
damageSticker.stickerID, damageSticker.rayStart,
damageSticker.rayEnd)
if isDetachedTurret:
gunGeometry = compoundModel.getPartGeometryLink(
DetachedTurretPartIndexes.GUN)
else:
gunGeometry = compoundModel.getPartGeometryLink(
TankPartIndexes.GUN)
for key in set(Insignia.Types.ALL) & set(self.__stickers.keys()):
gunNode, toPartRoot = self.__getInsigniaAttachNode(
key, isDamaged, compoundModel)
if gunNode is None:
return
self.__stickers[key].stickers.attachStickers(
gunGeometry, gunNode, isDamaged, toPartRoot)
return
def attach(self, compoundModel, isDamaged, showDamageStickers):
for componentName, attachNodeName in VehicleStickers.COMPONENT_NAMES:
idx = TankPartNames.getIdx(componentName)
node = compoundModel.node(attachNodeName)
if node is None:
continue
geometryLink = compoundModel.getPartGeometryLink(idx)
componentStickers = self.__stickers[componentName]
componentStickers.stickers.attachStickers(geometryLink, node,
isDamaged)
if showDamageStickers:
for damageSticker in componentStickers.damageStickers.itervalues(
):
if damageSticker.handle is not None:
componentStickers.stickers.delDamageSticker(
damageSticker.handle)
damageSticker.handle = None
LOG_WARNING(
'Adding %s damage sticker to occupied slot' %
componentName)
damageSticker.handle = componentStickers.stickers.addDamageSticker(
damageSticker.stickerID, damageSticker.rayStart,
damageSticker.rayEnd)
if isDamaged:
gunNode = compoundModel.node(TankPartNames.GUN)
elif self.__animateGunInsignia:
gunNode = compoundModel.node(
TankNodeNames.GUN_INCLINATION
) if isDamaged else compoundModel.node(
VehicleStickers.__INSIGNIA_NODE_NAME)
else:
gunNode = compoundModel.node(TankNodeNames.GUN_INCLINATION)
if gunNode is None:
return
else:
gunGeometry = compoundModel.getPartGeometryLink(
TankPartIndexes.GUN)
if isDamaged:
toPartRoot = mathUtils.createIdentityMatrix()
else:
toPartRoot = Math.Matrix(gunNode)
toPartRoot.invert()
toPartRoot.preMultiply(
compoundModel.node(TankNodeNames.GUN_INCLINATION))
self.__stickers['gunInsignia'].stickers.attachStickers(
gunGeometry, gunNode, isDamaged, toPartRoot)
return
def setupCollisions(vehicleDesc, collisions):
hitTestersByPart = {TankPartNames.CHASSIS: vehicleDesc.chassis.hitTester,
TankPartNames.HULL: vehicleDesc.hull.hitTester,
TankPartNames.TURRET: vehicleDesc.turret.hitTester,
TankPartNames.GUN: vehicleDesc.gun.hitTester}
for partName, hitTester in hitTestersByPart.iteritems():
partID = TankPartNames.getIdx(partName)
hitTester.bbox = collisions.getBoundingBox(partID)
if not hitTester.bbox:
_logger.error("Couldn't find bounding box for the part '%s' (collisions=%s)", partName, collisions)
trackPairs = vehicleDesc.chassis.trackPairs[1:]
for idx, trackPair in enumerate(trackPairs):
trackPair.hitTester.bbox = collisions.getBoundingBox(trackPairIdxToCollisionIdx(idx))
if not trackPair.hitTester.bbox:
_logger.error("Couldn't find bounding box for the track pair '%i' (collisions=%s)", idx, collisions)
def onAddedSticker(self, shotDamage, damageSticker, transform):
geometryLink = shotDamage.compound.getPartGeometryLink(
TankPartNames.getIdx(shotDamage.partName))
m = Math.Matrix()
m.setIdentity()
stickerModel = damageSticker.stickerModel
stickerModel.setupSuperModel(geometryLink, m)
node = shotDamage.compound.node(shotDamage.partName)
node.attach(damageSticker.stickerModel)
stickerModel.setLODDistance(damageSticker.lodDistance)
stickerId = vehicles.g_cache.damageStickers['ids'][
damageSticker.damageSticker]
segStart = transform.transform.applyPoint(
Math.Vector3(0, 0, -damageSticker.offset))
segEnd = transform.transform.applyPoint(
Math.Vector3(0, 0, damageSticker.offset))
stickerModel.addDamageSticker(stickerId, segStart, segEnd, True)
stickerModel.setupFadeout(damageSticker.fadeoutTime)
def prepareCollisionAssembler(vehicleDesc, isTurretDetached, worldID):
hitTestersByPart = {TankPartNames.CHASSIS: vehicleDesc.chassis.hitTester,
TankPartNames.HULL: vehicleDesc.hull.hitTester}
if not isTurretDetached:
hitTestersByPart[TankPartNames.TURRET] = vehicleDesc.turret.hitTester
hitTestersByPart[TankPartNames.GUN] = vehicleDesc.gun.hitTester
bspModels = []
for partName, hitTester in hitTestersByPart.iteritems():
partId = TankPartNames.getIdx(partName)
bspModel = (partId, hitTester.bspModelName, (0.0, 0.0, 0.0))
bspModels.append(bspModel)
trackPairs = vehicleDesc.chassis.trackPairs[1:]
for idx, trackPair in enumerate(trackPairs):
totalDefaultParts = len(TankPartNames.ALL)
bspModels.append((totalDefaultParts + idx, trackPair.hitTester.bspModelName))
assembler = BigWorld.CollisionAssembler(tuple(bspModels), worldID)
return assembler
def applyCamoCache(outfit, vehName, seasonCache):
itemsCache = dependency.instance(IItemsCache)
camouflages = items.vehicles.g_cache.customization20().camouflages
applied = False
cleaned = False
for areaName in seasonCache.keys():
try:
areaId = TankPartNames.getIdx(areaName)
except Exception as e:
print g_config.ID + ': exception while reading camouflages cache for', vehName, 'in', areaName + ':', e.message
continue
slot = outfit.getContainer(areaId).slotFor(GUI_ITEM_TYPE.CAMOUFLAGE)
if not seasonCache[areaName]:
slot.remove(0)
continue
camoID, paletteIdx, scale = seasonCache[areaName]
if camoID not in camouflages:
print '%s: wrong camouflage ID for %s:' % (g_config.ID,
areaName), camoID
del seasonCache[areaName]
continue
intCD = camouflages[camoID].compactDescr
if itemsCache.items.isSynced():
item = itemsCache.items.getItemByCD(intCD)
else:
item = Camouflage(intCD)
if paletteIdx > len(item.palettes):
print g_config.ID + ': wrong palette idx for', areaName, 'camouflage:', paletteIdx, '(available: %s)' % range(
len(item.palettes))
del seasonCache[areaName]
continue
if scale > len(item.scales):
print g_config.ID + ': wrong scale for', areaName, 'camouflage:', scale, '(available: %s)' % range(
len(item.scales))
slot.set(item)
component = slot.getComponent()
component.palette = paletteIdx
component.patternSize = scale
applied = True
if not seasonCache:
cleaned = True
outfit.invalidate()
return applied, cleaned
def collideDynamicAndStatic(startPoint,
endPoint,
exceptIDs,
collisionFlags=128,
skipGun=False):
ignoreDynamicID = 0
if exceptIDs:
ignoreDynamicID = exceptIDs[0]
testRes = BigWorld.wg_collideDynamicStatic(
BigWorld.player().spaceID, startPoint, endPoint, collisionFlags,
ignoreDynamicID,
-1 if not skipGun else TankPartNames.getIdx(TankPartNames.GUN))
if testRes is not None:
if testRes[1]:
return (testRes[0],
EntityCollisionData(testRes[2], testRes[3], testRes[4],
True))
return (testRes[0], None)
else:
return
def __setupModel(self, buildIdx):
self.__assembleModel()
cfg = hangarCFG()
matrix = mathUtils.createSRTMatrix(
Math.Vector3(cfg['v_scale'], cfg['v_scale'], cfg['v_scale']),
Math.Vector3(self.__vEntity.yaw, self.__vEntity.pitch,
self.__vEntity.roll), self.__vEntity.position)
self.__vEntity.model.matrix = matrix
self.__doFinalSetup(buildIdx)
self.__vEntity.typeDescriptor = self.__vDesc
gunColBox = self.collisions.getBoundingBox(
TankPartNames.getIdx(TankPartNames.GUN) + 3)
center = 0.5 * (gunColBox[1] - gunColBox[0])
gunoffset = Math.Matrix()
gunoffset.setTranslate((0.0, 0.0, center.z + gunColBox[0].z))
gunLink = mathUtils.MatrixProviders.product(
gunoffset, self.__vEntity.model.node(TankPartNames.GUN))
collisionData = ((TankPartNames.getIdx(TankPartNames.CHASSIS),
self.__vEntity.model.matrix),
(TankPartNames.getIdx(TankPartNames.HULL),
self.__vEntity.model.node(TankPartNames.HULL)),
(TankPartNames.getIdx(TankPartNames.TURRET),
self.__vEntity.model.node(TankPartNames.TURRET)),
(TankPartNames.getIdx(TankPartNames.GUN),
self.__vEntity.model.node(TankPartNames.GUN)))
self.collisions.connect(self.__vEntity.id,
ColliderTypes.VEHICLE_COLLIDER, collisionData)
collisionData = ((TankPartNames.getIdx(TankPartNames.GUN) + 1,
self.__vEntity.model.node(TankPartNames.HULL)),
(TankPartNames.getIdx(TankPartNames.GUN) + 2,
self.__vEntity.model.node(TankPartNames.TURRET)),
(TankPartNames.getIdx(TankPartNames.GUN) + 3,
gunLink))
self.collisions.connect(self.__vEntity.id,
ColliderTypes.HANGAR_VEHICLE_COLLIDER,
collisionData)
self.__reloadColliderType(self.__vEntity.state)
self.__reloadShadowManagerTarget(self.__vEntity.state)
def __correctEmblemLookAgainstGun(self, hitPos, dir, up, emblem):
checkDirWorld = dir * -10.0
cornersWorld = self.__getEmblemCorners(hitPos, dir, up, emblem)
result = self.collisions.collideShape(TankPartNames.getIdx(TankPartNames.GUN), (cornersWorld[0],
cornersWorld[1],
cornersWorld[2],
cornersWorld[3]), checkDirWorld)
if result < 0.0:
return dir
dirRot = Math.Matrix()
angle = _HANGAR_UNDERGUN_EMBLEM_ANGLE_SHIFT
turretMat = Math.Matrix(self.__vEntity.model.node(TankPartNames.TURRET))
fromTurretToHit = hitPos - turretMat.translation
gunDir = turretMat.applyVector(Math.Vector3(0, 0, 1))
if Math.Vector3(0, 1, 0).dot(gunDir * fromTurretToHit) < 0:
angle = -angle
dirRot.setRotateY(angle)
normRot = Math.Matrix()
normRot.setRotateYPR((dir.yaw, dir.pitch, 0))
dirRot.postMultiply(normRot)
dir = dirRot.applyVector(Math.Vector3(0, 0, 1))
return dir
def __init__(self, vehicleDesc, insigniaRank=0, outfit=None):
self.__showEmblemsOnGun = vehicleDesc.turret.showEmblemsOnGun
self.__defaultAlpha = vehicleDesc.type.emblemsAlpha
self.__show = True
self.__animateGunInsignia = vehicleDesc.gun.animateEmblemSlots
self.__currentInsigniaRank = insigniaRank
if outfit is None:
outfit = Outfit()
componentSlots = ((TankPartNames.HULL, vehicleDesc.hull.emblemSlots),
(TankPartNames.GUN if self.__showEmblemsOnGun else
TankPartNames.TURRET,
vehicleDesc.turret.emblemSlots),
(TankPartNames.TURRET
if self.__showEmblemsOnGun else TankPartNames.GUN,
[]), ('gunInsignia', vehicleDesc.gun.emblemSlots))
self.__stickers = {}
for componentName, emblemSlots in componentSlots:
try:
componentIdx = TankPartNames.getIdx(componentName)
except Exception:
componentIdx = -1
container = outfit.getContainer(componentIdx)
emblems = None
inscriptions = None
if container:
emblems = container.slotFor(GUI_ITEM_TYPE.EMBLEM)
inscriptions = container.slotFor(GUI_ITEM_TYPE.INSCRIPTION)
decals = {
SlotTypes.PLAYER: emblems,
SlotTypes.INSCRIPTION: inscriptions
}
modelStickers = ModelStickers(vehicleDesc, emblemSlots, decals,
componentName == TankPartNames.HULL,
self.__currentInsigniaRank)
self.__stickers[componentName] = ComponentStickers(
modelStickers, {}, 1.0)
return
def _connectCollider(self):
if self.collisions is not None:
chassisColisionMatrix, gunNodeName = self._vehicleColliderInfo
if self.isTurretDetached:
self.collisions.removeAttachment(
TankPartNames.getIdx(TankPartNames.TURRET))
self.collisions.removeAttachment(
TankPartNames.getIdx(TankPartNames.GUN))
collisionData = ((TankPartNames.getIdx(TankPartNames.HULL),
self.compoundModel.node(TankPartNames.HULL)),
(TankPartNames.getIdx(TankPartNames.CHASSIS),
chassisColisionMatrix))
else:
collisionData = ((TankPartNames.getIdx(TankPartNames.HULL),
self.compoundModel.node(TankPartNames.HULL)),
(TankPartNames.getIdx(TankPartNames.TURRET),
self.compoundModel.node(
TankPartNames.TURRET)),
(TankPartNames.getIdx(TankPartNames.CHASSIS),
chassisColisionMatrix),
(TankPartNames.getIdx(TankPartNames.GUN),
self.compoundModel.node(gunNodeName)))
defaultPartLength = len(TankPartNames.ALL)
additionalChassisParts = []
trackPairs = self.typeDescriptor.chassis.trackPairs
if not trackPairs:
trackPairs = [None]
for x in xrange(len(trackPairs) - 1):
additionalChassisParts.append(
(defaultPartLength + x, chassisColisionMatrix))
if additionalChassisParts:
collisionData += tuple(additionalChassisParts)
self.collisions.connect(self.id, ColliderTypes.VEHICLE_COLLIDER,
collisionData)
return
def __init__(self, vehicleDesc, insigniaRank=0, outfit=None):
self.__defaultAlpha = vehicleDesc.type.emblemsAlpha
self.__show = True
self.__animateGunInsignia = vehicleDesc.gun.animateEmblemSlots
self.__currentInsigniaRank = insigniaRank
self.__vDesc = vehicleDesc
self.__componentNames = [(TankPartNames.HULL, TankPartNames.HULL),
(TankPartNames.TURRET, TankPartNames.TURRET),
(TankPartNames.GUN,
TankNodeNames.GUN_INCLINATION)]
if outfit is None:
outfit = Outfit(vehicleCD=vehicleDesc.makeCompactDescr())
componentSlots = self._createComponentSlots(
vehicleDesc, vehicleDesc.turret.showEmblemsOnGun, outfit)
if not isUseDebugStickers():
self.__stickerPacks = self._createStickerPacks(
vehicleDesc, outfit, insigniaRank)
else:
self.__stickerPacks = self._createDebugStickerPacks(
vehicleDesc, outfit, insigniaRank)
self.__stickers = {}
for componentName, emblemSlots in componentSlots:
if componentName == Insignia.Types.SINGLE:
componentIdx = Insignia.Indexes.SINGLE
elif componentName == Insignia.Types.DUAL_LEFT:
componentIdx = Insignia.Indexes.DUAL_LEFT
elif componentName == Insignia.Types.DUAL_RIGHT:
componentIdx = Insignia.Indexes.DUAL_RIGHT
else:
componentIdx = TankPartNames.getIdx(componentName)
modelStickers = ModelStickers(componentIdx, self.__stickerPacks,
vehicleDesc, emblemSlots)
self.__stickers[componentName] = ComponentStickers(
modelStickers, {}, 1.0)
return
def applyOutfitCache(outfit, seasonCache, clean=True):
itemsCache = dependency.instance(IItemsCache)
for itemTypeName, itemCache in seasonCache.items():
itemType = GUI_ITEM_TYPE_INDICES[itemTypeName]
itemDB = items.vehicles.g_cache.customization20().itemTypes[
C11N_ITEM_TYPE_MAP[itemType]]
for areaName, areaCache in itemCache.items():
areaId = (Area.MISC if areaName == 'misc' else
TankPartNames.getIdx(areaName))
slot = outfit.getContainer(areaId).slotFor(itemType)
for regionIdx in areaCache.keys():
itemID = areaCache[regionIdx]['id']
if itemID is None:
if slot.getItem(int(regionIdx)) is not None:
slot.remove(int(regionIdx))
elif clean: # item is being deleted while not applied at all. possible change after last cache
del areaCache[
regionIdx] # so we remove an obsolete key
continue
if itemID not in itemDB:
print g_config.ID + ': wrong item ID for %s, idx %s:' % (
areaName, regionIdx), itemID
del areaCache[regionIdx]
continue
intCD = itemDB[itemID].compactDescr
item = (
itemsCache.items.getItemByCD
if itemsCache.items.isSynced() else
itemsCache.items.itemsFactory.createCustomization)(intCD)
component = emptyComponent(itemType)
[
setattr(component, k, v)
for k, v in areaCache[regionIdx].items()
]
slot.set(item, int(regionIdx), component)
outfit.invalidate()
def prerequisites(self,
typeDescriptor,
vID,
health=1,
isCrewActive=True,
isTurretDetached=False,
outfitCD=''):
prereqs = self.__appearance.prerequisites(typeDescriptor, vID, health,
isCrewActive,
isTurretDetached, outfitCD)
compoundAssembler = prepareCompoundAssembler(
typeDescriptor, self.__appearance.modelsSetParams,
BigWorld.player().spaceID, isTurretDetached)
if not isTurretDetached:
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS),
typeDescriptor.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL),
typeDescriptor.hull.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.TURRET),
typeDescriptor.turret.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.GUN),
typeDescriptor.gun.hitTester.bspModelName))
else:
bspModels = ((TankPartNames.getIdx(TankPartNames.CHASSIS),
typeDescriptor.chassis.hitTester.bspModelName),
(TankPartNames.getIdx(TankPartNames.HULL),
typeDescriptor.hull.hitTester.bspModelName))
collisionAssembler = BigWorld.CollisionAssembler(
bspModels,
BigWorld.player().spaceID)
prereqs += [compoundAssembler, collisionAssembler]
physicalTracksBuilders = typeDescriptor.chassis.physicalTracks
for name, builder in physicalTracksBuilders.iteritems():
prereqs.append(
builder.createLoader('{0}PhysicalTrack'.format(name)))
return (compoundAssembler, prereqs)
def __startBuild(self, vDesc, vState):
self.__curBuildInd += 1
self.__vState = vState
self.__resources = {}
self.__vehicleStickers = None
cfg = hangarCFG()
if vState == 'undamaged':
self.__currentEmblemsAlpha = cfg['emblems_alpha_undamaged']
self.__isVehicleDestroyed = False
else:
self.__currentEmblemsAlpha = cfg['emblems_alpha_damaged']
self.__isVehicleDestroyed = True
self.__vDesc = vDesc
resources = camouflages.getCamoPrereqs(self.__outfit, vDesc)
if not self.__isVehicleDestroyed:
self.__attachments = camouflages.getAttachments(self.__outfit, vDesc)
modelsSet = self.__outfit.modelsSet
splineDesc = vDesc.chassis.splineDesc
if splineDesc is not None:
for _, trackDesc in splineDesc.trackPairs.iteritems():
resources += trackDesc.prerequisites(modelsSet)
from vehicle_systems import model_assembler
resources.append(model_assembler.prepareCompoundAssembler(self.__vDesc, ModelsSetParams(modelsSet, self.__vState, self.__attachments), self.__spaceId))
g_eventBus.handleEvent(CameraRelatedEvents(CameraRelatedEvents.VEHICLE_LOADING, ctx={'started': True,
'vEntityId': self.__vEntity.id,
'intCD': self.__vDesc.type.compactDescr}), scope=EVENT_BUS_SCOPE.DEFAULT)
cfg = hangarCFG()
gunScale = Math.Vector3(1.0, 1.0, 1.1)
capsuleScale = Math.Vector3(1.5, 1.5, 1.5)
loadedGunScale = cfg.get('cam_capsule_gun_scale', gunScale)
if loadedGunScale is not None:
gunScale = loadedGunScale
loadedCapsuleScale = cfg.get('cam_capsule_scale', capsuleScale)
if loadedCapsuleScale is not None:
capsuleScale = loadedCapsuleScale
hitTesterManagers = {TankPartNames.CHASSIS: vDesc.chassis.hitTesterManager,
TankPartNames.HULL: vDesc.hull.hitTesterManager,
TankPartNames.TURRET: vDesc.turret.hitTesterManager,
TankPartNames.GUN: vDesc.gun.hitTesterManager}
bspModels = ()
crashedBspModels = ()
for partName, htManager in hitTesterManagers.iteritems():
partId = TankPartNames.getIdx(partName)
bspModel = (partId, htManager.modelHitTester.bspModelName)
bspModels = bspModels + (bspModel,)
if htManager.crashedModelHitTester:
crashedBspModel = (partId, htManager.crashedModelHitTester.bspModelName)
crashedBspModels = crashedBspModels + (crashedBspModel,)
bspModels = bspModels + ((TankPartNames.getIdx(TankPartNames.GUN) + 1, vDesc.hull.hitTesterManager.modelHitTester.bspModelName, capsuleScale), (TankPartNames.getIdx(TankPartNames.GUN) + 2, vDesc.turret.hitTesterManager.modelHitTester.bspModelName, capsuleScale), (TankPartNames.getIdx(TankPartNames.GUN) + 3, vDesc.gun.hitTesterManager.modelHitTester.bspModelName, gunScale))
if vDesc.hull.hitTesterManager.crashedModelHitTester:
crashedBspModels = crashedBspModels + ((TankPartNames.getIdx(TankPartNames.GUN) + 1, vDesc.hull.hitTesterManager.crashedModelHitTester.bspModelName, capsuleScale),)
if vDesc.turret.hitTesterManager.crashedModelHitTester:
crashedBspModels = crashedBspModels + ((TankPartNames.getIdx(TankPartNames.GUN) + 2, vDesc.turret.hitTesterManager.crashedModelHitTester.bspModelName, capsuleScale),)
if vDesc.gun.hitTesterManager.crashedModelHitTester:
crashedBspModels = crashedBspModels + ((TankPartNames.getIdx(TankPartNames.GUN) + 3, vDesc.gun.hitTesterManager.crashedModelHitTester.bspModelName, gunScale),)
modelCA = BigWorld.CollisionAssembler(bspModels, self.__spaceId)
modelCA.name = 'ModelCollisions'
resources.append(modelCA)
if crashedBspModels:
crashedModelCA = BigWorld.CollisionAssembler(crashedBspModels, self.__spaceId)
crashedModelCA.name = 'CrashedModelCollisions'
resources.append(crashedModelCA)
physicalTracksBuilders = vDesc.chassis.physicalTracks
for name, builders in physicalTracksBuilders.iteritems():
for index, builder in enumerate(builders):
resources.append(builder.createLoader(self.__spaceId, '{0}{1}PhysicalTrack'.format(name, index), modelsSet))
BigWorld.loadResourceListBG(tuple(resources), makeCallbackWeak(self.__onResourcesLoaded, self.__curBuildInd))
return
def construct(self, isPlayer, resourceRefs):
self.collisions = resourceRefs['collisionAssembler']
self.typeDescriptor.chassis.hitTester.bbox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.CHASSIS))
self.typeDescriptor.hull.hitTester.bbox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.HULL))
self.typeDescriptor.turret.hitTester.bbox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.TURRET))
self.typeDescriptor.gun.hitTester.bbox = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.GUN))
self.__isObserver = 'observer' in self.typeDescriptor.type.tags
self._compoundModel = resourceRefs[self.typeDescriptor.name]
self.__boundEffects = bound_effects.ModelBoundEffects(self.compoundModel)
isCurrentModelDamaged = self.damageState.isCurrentModelDamaged
fashions = camouflages.prepareFashions(isCurrentModelDamaged)
if not isCurrentModelDamaged:
model_assembler.setupTracksFashion(self.typeDescriptor, fashions.chassis)
self._setFashions(fashions, self.isTurretDetached)
self._setupModels()
if not isCurrentModelDamaged:
modelsSet = self.outfit.modelsSet
self._splineTracks = model_assembler.setupSplineTracks(self.fashion, self.typeDescriptor, self.compoundModel, resourceRefs, modelsSet)
self.crashedTracksController = CrashedTrackController(self.typeDescriptor, self.fashion, modelsSet)
else:
self.__trackScrollCtl = None
self._chassisDecal.create()
self.__modelAnimators = camouflages.getModelAnimators(self.outfit, self.typeDescriptor, self.worldID, resourceRefs, self.compoundModel)
if self.modelsSetParams.state == 'undamaged':
self.__modelAnimators.extend(camouflages.getAttachmentsAnimators(self.__attachments, self.worldID, resourceRefs, self.compoundModel))
self.transform = self.createComponent(GenericComponents.TransformComponent, Math.Vector3(0, 0, 0))
self.areaTriggerTarget = self.createComponent(Triggers.AreaTriggerTarget)
self.__filter = model_assembler.createVehicleFilter(self.typeDescriptor)
compoundModel = self.compoundModel
if self.isAlive:
self.detailedEngineState, self.gearbox = model_assembler.assembleDrivetrain(self, isPlayer)
if not gEffectsDisabled():
self.customEffectManager = CustomEffectManager(self)
if self.typeDescriptor.hasSiegeMode:
self.siegeEffects = SiegeEffectsController(self, isPlayer)
model_assembler.assembleVehicleAudition(isPlayer, self)
self.detailedEngineState.onEngineStart = self._onEngineStart
self.detailedEngineState.onStateChanged = self.engineAudition.onEngineStateChanged
if isPlayer:
turret = self.typeDescriptor.turret
gunRotatorAudition = self.createComponent(Vehicular.GunRotatorAudition, turret.turretRotatorSoundManual, turret.weight / 1000.0, compoundModel.node(TankPartNames.TURRET))
gunRotatorAudition.vehicleMatrixLink = self.compoundModel.root
gunRotatorAudition.damaged = lambda : self.turretDamaged()
gunRotatorAudition.maxTurretRotationSpeed = lambda : self.maxTurretRotationSpeed()
self.gunRotatorAudition = gunRotatorAudition
self.frictionAudition = self.createComponent(Vehicular.FrictionAudition, TANK_FRICTION_EVENT)
isLodTopPriority = isPlayer
lodCalcInst = self.createComponent(Vehicular.LodCalculator, DataLinks.linkMatrixTranslation(compoundModel.matrix), True, VEHICLE_PRIORITY_GROUP, isLodTopPriority)
self.lodCalculator = lodCalcInst
self.allLodCalculators.append(lodCalcInst)
lodLink = DataLinks.createFloatLink(lodCalcInst, 'lodDistance')
lodStateLink = lodCalcInst.lodStateLink
if IS_EDITOR:
matrixBinding = None
changeCamera = None
else:
matrixBinding = BigWorld.player().consistentMatrices.onVehicleMatrixBindingChanged
changeCamera = BigWorld.player().inputHandler.onCameraChanged
self.shadowManager = VehicleShadowManager(compoundModel, matrixBinding, changeCamera)
if not self.damageState.isCurrentModelDamaged:
self.__assembleNonDamagedOnly(resourceRefs, isPlayer, lodLink, lodStateLink)
dirtEnabled = BigWorld.WG_dirtEnabled() and 'HD' in self.typeDescriptor.type.tags
if dirtEnabled and self.fashions is not None:
dirtHandlers = [BigWorld.PyDirtHandler(True, compoundModel.node(TankPartNames.CHASSIS).position.y),
BigWorld.PyDirtHandler(False, compoundModel.node(TankPartNames.HULL).position.y),
BigWorld.PyDirtHandler(False, compoundModel.node(TankPartNames.TURRET).position.y),
BigWorld.PyDirtHandler(False, compoundModel.node(TankPartNames.GUN).position.y)]
modelHeight, _ = self.computeVehicleHeight()
self.dirtComponent = self.createComponent(Vehicular.DirtComponent, dirtHandlers, modelHeight)
for fashionIdx, _ in enumerate(TankPartNames.ALL):
self.fashions[fashionIdx].addMaterialHandler(dirtHandlers[fashionIdx])
self.fashions[fashionIdx].addTrackMaterialHandler(dirtHandlers[fashionIdx])
model_assembler.setupTurretRotations(self)
self.waterSensor = model_assembler.assembleWaterSensor(self.typeDescriptor, self, lodStateLink, self.worldID)
if self.engineAudition is not None:
self.engineAudition.setIsUnderwaterInfo(DataLinks.createBoolLink(self.waterSensor, 'isUnderWater'))
self.engineAudition.setIsInWaterInfo(DataLinks.createBoolLink(self.waterSensor, 'isInWater'))
self.__postSetupFilter()
compoundModel.setPartBoundingBoxAttachNode(TankPartIndexes.GUN, TankNodeNames.GUN_INCLINATION)
camouflages.updateFashions(self)
model_assembler.assembleCustomLogicComponents(self, self.__attachments, self.__modelAnimators)
return
def computeVehicleLength(self):
vehicleLength = 0.0
if self.collisions is not None:
hullBB = self.collisions.getBoundingBox(TankPartNames.getIdx(TankPartNames.HULL))
vehicleLength = abs(hullBB[1][2] - hullBB[0][2])
return vehicleLength
def _getBBCenter(tankPartName):
partIdx = TankPartNames.getIdx(tankPartName)
boundingBox = Math.Matrix(
self.__vEntity.model.getBoundsForPart(partIdx))
bbCenter = boundingBox.applyPoint((0.5, 0.5, 0.5))
return bbCenter
def addCameraCollider(self):
collider = self.collisions
if collider is not None:
colliderData = (collider.getColliderID(), (TankPartNames.getIdx(TankPartNames.HULL), TankPartNames.getIdx(TankPartNames.TURRET)))
BigWorld.appendCameraCollider(colliderData)
return
def activate(self):
if self.__activated or self.__vehicle is None:
return
else:
if self.collisions is not None and self.__vehicle.isTurretDetached:
self.collisions.removeAttachment(
TankPartNames.getIdx(TankPartNames.TURRET))
self.collisions.removeAttachment(
TankPartNames.getIdx(TankPartNames.GUN))
super(CompoundAppearance, self).activate()
isPlayerVehicle = self.__vehicle.isPlayerVehicle
self.__isObserver = 'observer' in self.__typeDesc.type.tags
player = BigWorld.player()
self.__originalFilter = self.__vehicle.filter
self.__vehicle.filter = self.__filter
self.__vehicle.filter.enableStabilisedMatrix(isPlayerVehicle)
self.__filter.isStrafing = self.__vehicle.isStrafing
self.__filter.vehicleCollisionCallback = player.handleVehicleCollidedVehicle
if isPlayerVehicle and self.collisions is not None:
colliderData = (self.collisions.getColliderID(),
(TankPartNames.getIdx(TankPartNames.HULL),
TankPartNames.getIdx(TankPartNames.TURRET)))
BigWorld.appendCameraCollider(colliderData)
self.__inSpeedTreeCollision = True
BigWorld.setSpeedTreeCollisionBody(
self.__compoundModel.getBoundsForPart(
TankPartIndexes.HULL))
self.__linkCompound()
if not self.__isObserver:
self.__chassisDecal.attach()
self.__createAndAttachStickers()
if self.__currentDamageState.isCurrentModelDamaged:
self.__chassisColisionMatrix.target = self.__compoundModel.matrix
gunNodeName = 'gun'
else:
self.__chassisColisionMatrix.target = self.__vehicle.filter.groundPlacingMatrix
gunNodeName = TankNodeNames.GUN_INCLINATION
if not self.__isObserver:
self.__startSystems()
self.setupGunMatrixTargets()
if not self.__isObserver:
self.__vehicle.filter.enableLagDetection(
not self.__currentDamageState.isCurrentModelDamaged)
self.onModelChanged()
if self.lodCalculator is not None:
self.lodCalculator.setupPosition(
DataLinks.linkMatrixTranslation(
self.__compoundModel.matrix))
if hasattr(self.filter, 'placingCompensationMatrix'
) and self.swingingAnimator is not None:
self.swingingAnimator.placingCompensationMatrix = self.filter.placingCompensationMatrix
self.swingingAnimator.worldMatrix = self.__compoundModel.matrix
if not self.__isObserver:
if self.__periodicTimerID is not None:
BigWorld.cancelCallback(self.__periodicTimerID)
self.__periodicTimerID = BigWorld.callback(
_PERIODIC_TIME, self.__onPeriodicTimer)
self.__dirtUpdateTime = BigWorld.time()
if self.fashion is not None:
self.fashion.activate()
if self.__isObserver:
self.__compoundModel.visible = False
BigWorld.player().arena.onPeriodChange += self.__arenaPeriodChanged
BigWorld.player(
).inputHandler.onCameraChanged += self.__onCameraChanged
if self.detailedEngineState is not None:
engine_state.checkEngineStart(self.detailedEngineState,
BigWorld.player().arena.period)
if self.collisions is not None:
collisionData = ((TankPartNames.getIdx(TankPartNames.HULL),
self.compoundModel.node(TankPartNames.HULL)),
(TankPartNames.getIdx(TankPartNames.TURRET),
self.compoundModel.node(
TankPartNames.TURRET)),
(TankPartNames.getIdx(TankPartNames.CHASSIS),
self.__chassisColisionMatrix),
(TankPartNames.getIdx(TankPartNames.GUN),
self.compoundModel.node(gunNodeName)))
self.collisions.connect(self.id,
ColliderTypes.VEHICLE_COLLIDER,
collisionData)
self.__activated = True
return
