def __createTransform(slotParams, slotData):
worldTransform = math_utils.createRTMatrix(slotParams.rotation,
slotParams.position)
objectTransform = math_utils.createRTMatrix(
Math.Vector3(slotData.component.rotation),
Math.Vector3(slotData.component.position))
worldTransform.postMultiply(objectTransform)
return worldTransform
def attachModels(assembler, vehicleDesc, modelsSetParams, isTurretDetached, renderMode=None, overlayCollision=False):
collisionState = renderMode in (TankRenderMode.CLIENT_COLLISION,
TankRenderMode.SERVER_COLLISION,
TankRenderMode.CRASH_COLLISION,
TankRenderMode.ARMOR_WIDTH_COLLISION)
if collisionState:
partModels = getCollisionModelsFromDesc(vehicleDesc, renderMode)
else:
partModels = getPartModelsFromDesc(vehicleDesc, modelsSetParams)
chassis, hull, turret, gun = partModels
partNames = TankPartNames
if overlayCollision:
partNames = TankCollisionPartNames
if not overlayCollision:
assembler.addRootPart(chassis, TankPartNames.CHASSIS)
else:
assembler.addPart(chassis, TankPartNames.CHASSIS, TankCollisionPartNames.CHASSIS)
if collisionState:
trackPairs = vehicleDesc.chassis.trackPairs[1:]
for idx, trackPair in enumerate(trackPairs):
assembler.addPart(trackPair.hitTester.bspModelName, partNames.CHASSIS, 'trackPair' + str(idx + 1))
if collisionState and vehicleDesc.isWheeledVehicle:
for i, wheel in enumerate(vehicleDesc.chassis.wheels.wheels):
bspPath = ''
if renderMode == TankRenderMode.CLIENT_COLLISION:
bspPath = wheel.hitTesterManager.edClientBspModel
elif renderMode in (TankRenderMode.SERVER_COLLISION, TankRenderMode.ARMOR_WIDTH_COLLISION):
bspPath = wheel.hitTesterManager.edServerBspModel
if bspPath:
assembler.addNode(wheel.nodeName, partNames.CHASSIS, math_utils.createTranslationMatrix(wheel.position))
assembler.emplacePart(bspPath, wheel.nodeName, TankCollisionPartNames.WHEEL + str(i))
if collisionState and not overlayCollision:
assembler.addNode('V', TankPartNames.CHASSIS, math_utils.createTranslationMatrix(vehicleDesc.chassis.hullPosition))
if not overlayCollision:
assembler.emplacePart(hull, 'V', partNames.HULL)
else:
assembler.addPart(hull, 'V', partNames.HULL)
turretJointName = vehicleDesc.hull.turretHardPoints[0]
assembler.addNodeAlias(turretJointName, TankNodeNames.TURRET_JOINT)
if not isTurretDetached:
if collisionState and not overlayCollision:
assembler.addNode(turretJointName, 'V', math_utils.createRTMatrix(Math.Vector3(0, vehicleDesc.hull.turretPitches[0], 0), vehicleDesc.hull.turretPositions[0]))
assembler.addPart(turret, turretJointName, partNames.TURRET)
if collisionState and not overlayCollision:
assembler.addNode(TankNodeNames.GUN_JOINT, TankPartNames.TURRET, math_utils.createRTMatrix(Math.Vector3(0, vehicleDesc.turret.gunJointPitch, 0), vehicleDesc.turret.gunPosition))
assembler.addPart(gun, TankNodeNames.GUN_JOINT, partNames.GUN)
if modelsSetParams.state == 'undamaged':
for attachment in modelsSetParams.attachments:
if attachment.attachmentLogic == 'prefab':
continue
assembler.addPart(attachment.modelName, attachment.attachNode, attachment.partNodeAlias, attachment.transform)
def getTurretJointMat(vehicleTypeDescriptor, vehicleMatrix, turretYaw=0.0, overrideTurretLocalZ=None):
turretOffset = getTurretJointOffset(vehicleTypeDescriptor)
if overrideTurretLocalZ is not None:
turretOffset.z = overrideTurretLocalZ
turretJointMat = math_utils.createRTMatrix(Vector3(turretYaw, 0, 0), turretOffset)
turretJointMat.postMultiply(vehicleMatrix)
return turretJointMat
def getGunJointMat(vehicleTypeDescriptor, turretMatrix, gunPitch, overrideTurretLocalZ=None):
gunOffset = Vector3(vehicleTypeDescriptor.activeGunShotPosition)
if overrideTurretLocalZ is not None:
offset = getTurretJointOffset(vehicleTypeDescriptor)
yOffset = math.tan(gunPitch) * offset.z
gunOffset.y += yOffset
gunMat = math_utils.createRTMatrix(Vector3(0, gunPitch, 0), gunOffset)
gunMat.postMultiply(turretMatrix)
return gunMat
def onEntityComponentAdded(self, entityComponent, transformComponent):
scaleMatrix = math_utils.createRTMatrix(
transformComponent.worldRotation, transformComponent.worldPosition)
scaleMatrix.invert()
scaleMatrix.preMultiply(transformComponent.worldTransform)
scaleCoeffs = scaleMatrix.applyVector((1, 1, 1))
state = {'scale': scaleCoeffs}
state.update(entityComponent.state)
rotationRPY = Math.Vector3(transformComponent.worldTransform.roll,
transformComponent.worldTransform.pitch,
transformComponent.worldTransform.yaw)
entityComponent.entityID = BigWorld.createEntity(
entityComponent.entityClass.__name__, self.spaceID, 0,
transformComponent.worldPosition, rotationRPY, state)
def __correctTurretYaw(self, anchorHelper, defaultYaw):
if not _SHOULD_CHECK_DECAL_UNDER_GUN:
return defaultYaw
else:
partMatrix = Math.Matrix(
self.__vEntity.model.node(
TankPartIndexes.getName(anchorHelper.partIdx)))
turretMat = Math.Matrix(
self.compoundModel.node(TankPartNames.TURRET))
transformMatrix = math_utils.createRTMatrix(
(turretMat.yaw, partMatrix.pitch, partMatrix.roll),
partMatrix.translation)
anchorLocationWS = self.__applyToAnchorLocation(
anchorHelper.location, transformMatrix)
position = anchorLocationWS.position
direction = anchorLocationWS.normal
up = anchorLocationWS.up
fromTurretToHit = position - turretMat.translation
if fromTurretToHit.dot(turretMat.applyVector((0, 0, 1))) < 0:
return defaultYaw
checkDirWorld = direction * 10.0
cornersWorldSpace = self.__getDecalCorners(position, direction, up,
anchorHelper.descriptor)
if cornersWorldSpace is None:
return defaultYaw
slotType = ANCHOR_TYPE_TO_SLOT_TYPE_MAP[
anchorHelper.descriptor.type]
if slotType == GUI_ITEM_TYPE.PROJECTION_DECAL:
turretLeftDir = turretMat.applyVector((1, 0, 0))
turretLeftDir.normalise()
gunJoin = self.__vEntity.model.node('HP_gunJoint')
fromGunJointToAnchor = gunJoin.position - position
decalDiags = (cornersWorldSpace[0] - cornersWorldSpace[2],
cornersWorldSpace[1] - cornersWorldSpace[3])
fromGunToHit = abs(fromGunJointToAnchor.dot(turretLeftDir))
halfDecalWidth = max((abs(decalDiag.dot(turretLeftDir))
for decalDiag in decalDiags)) * 0.5
if fromGunToHit > halfDecalWidth * _PROJECTION_DECAL_OVERLAPPING_FACTOR:
return defaultYaw
result = self.collisions.collideShape(TankPartIndexes.GUN,
cornersWorldSpace,
checkDirWorld)
if result < 0.0:
return defaultYaw
turretYaw = _HANGAR_TURRET_SHIFT
gunDir = turretMat.applyVector(Math.Vector3(0, 0, 1))
if Math.Vector3(0, 1, 0).dot(gunDir * fromTurretToHit) > 0.0:
turretYaw = -turretYaw
return turretYaw
def __init__(self):
BigWorld.UserDataObject.__init__(self)
self.__gameObject = CGF.GameObject(BigWorld.player().spaceID, 'SoundZoneTrigger')
self.__gameObject.setStatic(True)
position = math_utils.createRTMatrix(Math.Vector3(self.direction.z, self.direction.y, self.direction.x), self.position)
self.__gameObject.createComponent(TransformComponent, position)
self.__gameObject.createComponent(SoundZoneComponent, self.ZoneEnter, self.ZoneExit, self.Reverb, '', self.ReverbLevel, self.VolumeDeviation)
v = Math.Vector3(self.Size.x, self.Size.y, self.Size.z) * 0.5
self.__gameObject.createComponent(SquareAreaComponent, -v, v)
self.__gameObject.activate()
if VISUALISE_ZONE:
self.model = BigWorld.Model('objects/misc/bbox/unit_cube_1m_proxy.model')
BigWorld.player().addModel(self.model)
motor = BigWorld.Servo(Math.Matrix())
self.model.addMotor(motor)
motor.signal = math_utils.createSRTMatrix(Math.Vector3(self.Size.x, self.Size.y, self.Size.z), Math.Vector3(self.direction.z, self.direction.y, self.direction.x), self.position)
def _update(self):
worldMatrix = Matrix(self._cam.invViewMatrix)
desiredPosition = self.__basisMProv.checkTurretDetachment(
worldMatrix.translation)
if desiredPosition is not None:
self.__position = desiredPosition
prevPos = Math.Vector3(self.__position)
delta = self.__calcCurrentDeltaAdjusted()
self.__updateSenses(delta)
if self._targetRadiusSensor:
self.__rotationRadius += self._targetRadiusSensor.currentVelocity * delta
if self.__isVerticalVelocitySeparated:
self._verticalMovementSensor.update(delta)
else:
self._verticalMovementSensor.currentVelocity = self._movementSensor.currentVelocity.y
self._verticalMovementSensor.sensitivity = self._movementSensor.sensitivity
if self._inertiaEnabled:
self.__inertialMovement(delta)
else:
self.__simpleMovement(delta)
self.__ypr += self.__yprVelocity * delta
self.__position += self.__velocity * delta
if self.__rotateAroundPointEnabled:
self.__position = self.__getAlignedToPointPosition(
math_utils.createRotationMatrix(self.__ypr))
if self._alignerToLand.enabled and not self.__basisMProv.isBound:
if abs(self.__velocity.y) > 0.1:
self._alignerToLand.enable(self.__position,
self._alignerToLand.ignoreTerrain)
self.__position = self._alignerToLand.getAlignedPosition(
self.__position)
lookAtPosition = self.__basisMProv.lookAtPosition
if lookAtPosition is not None:
self.__ypr = self.__getLookAtYPR(lookAtPosition)
if BigWorld.camera(
) == self.__cameraTransition and self.__cameraTransition.isInTransition(
):
self.__ypr = self.__clampPR(self.__ypr)
else:
self.__ypr = self.__clampYPR(self.__ypr)
self.__position = self._checkSpaceBounds(prevPos, self.__position)
self._cam.invViewProvider.a = math_utils.createRTMatrix(
self.__ypr, self.__position)
self._cam.invViewProvider.b = self.__basisMProv.matrix
BigWorld.projection().fov = self.__calcFov()
self.__resetSenses()
return 0.0
def tick(self):
player = BigWorld.player()
if player is None or isPlayerAccount():
return
else:
if hasattr(player, 'getVehicleAttached'):
vehicle = player.getVehicleAttached()
if vehicle is None:
return
for hmodifier in self.queryCamera:
transfComp = hmodifier.cameraTransform()
direction = vehicle.position - transfComp.worldTransform.translation
matrix = transfComp.transform
transfComp.transform = math_utils.createRTMatrix(
(direction.yaw, direction.pitch, 0.0),
matrix.translation)
return
def setSelectingDirection(self, value=False):
if value and self.__terrainRotatedArea is None:
objectSize = Math.Vector2(10.0, 10.0)
self.__rotateModelNode = self.__fakeModel.node(
'',
math_utils.createRTMatrix(
Math.Vector3(-self.__matrix.yaw, 0.0, 0.0),
Math.Vector3((-self.__size.x - objectSize.x) * 0.5, 0.0,
(self.__size.y + objectSize.y) * 0.5)))
self.__terrainRotatedArea = area = BigWorld.PyTerrainSelectedArea()
area.setup(DEFAULT_ROTATE_MODEL, objectSize,
self.__overTerrainHeight, self.__color)
area.enableAccurateCollision(True)
area.setYCutOffDistance(MARKER_HEIGHT)
self.__rotateModelNode.attach(area)
elif not value and self.__terrainRotatedArea is not None:
self.__rotateModelNode.detach(self.__terrainRotatedArea)
self.__terrainRotatedArea = None
return
def __updateVehicleMarker(self, vehicleID, params):
self._vehiclesCallback[vehicleID] = None
markerIDs = self._vehiclesAreaMarker['ID']
if vehicleID not in markerIDs:
return
else:
vehicle = BigWorld.entities.get(vehicleID)
vehiclesMatrix = self._vehiclesAreaMarker['matrix']
markerIDs = markerIDs[vehicleID].values()
prevDataByVehID = self._vehiclesAreaMarker['prevData'][vehicleID]
lastCheckTime = self._vehiclesAreaMarker['lastCheckTime']
if vehicle:
matrix = vehicle.matrix
if not vehiclesMatrix[vehicleID]['inAoI']:
vehiclesMatrix.update({vehicleID: {'matrix': matrix,
'inAoI': True}})
for markerID in markerIDs:
self._parent.setMarkerMatrix(markerID, matrix)
else:
positionData = params['positionData']
position = positionData['position']
ypr = positionData['ypr']
if vehiclesMatrix[vehicleID]['inAoI']:
vehiclesMatrix.update({vehicleID: {'matrix': math_utils.createRTMatrix(ypr, position),
'inAoI': False}})
for markerID in markerIDs:
self._parent.setMarkerMatrix(markerID, vehiclesMatrix[vehicleID]['matrix'])
else:
matrix = vehiclesMatrix[vehicleID]['matrix']
if (prevDataByVehID['position'] - position).length < self._TELEPORT_DISTANCE:
dt = BigWorld.time() - lastCheckTime[vehicleID]
position = matrix.translation + positionData['velocity'] * dt
if prevDataByVehID['position'] != ypr:
matrix.setRotateYPR(ypr)
prevDataByVehID['ypr'] = ypr
matrix.translation = position
prevDataByVehID['position'] = position
lastCheckTime[vehicleID] = BigWorld.time()
self._vehiclesCallback[vehicleID] = BigWorld.callback(self._TICK_UPDATE, partial(self.__updateVehicleMarker, vehicleID, params))
return
def _updateMatrix(self):
vehiclePosition = Vector3(BigWorld.player().getVehicleAttached().position)
vehiclePosition.y = self._planePosition.y
diff = self._planePosition - vehiclePosition
if diff.lengthSquared < _MINIMAL_AIMING_RADIUS_SQ:
diff.normalise()
self._planePosition = vehiclePosition + diff * _MINIMAL_AIMING_RADIUS
self._clampToArenaBB()
hitPoint = BigWorld.wg_collideSegment(BigWorld.player().spaceID, self._planePosition + Vector3(0.0, 1000.0, 0.0), self._planePosition + Vector3(0.0, -250.0, 0.0), 128, 8)
aimPoint = Vector3(self._planePosition)
if hitPoint is not None:
aimPoint.y = hitPoint.closestPoint[1]
r0, v0, g0 = BigWorld.player().gunRotator.getShotParams(aimPoint, True)
hitPoint = BigWorld.wg_simulateProjectileTrajectory(r0, v0, g0, SERVER_TICK_LENGTH, SHELL_TRAJECTORY_EPSILON_CLIENT, 128)
if hitPoint is not None:
time = (aimPoint.x - r0.x) / v0.x
self.__direction = v0 + g0 * time
self.__direction.normalise()
self._matrix = math_utils.createRTMatrix((self.__direction.yaw, -self.__direction.pitch, 0.0), hitPoint[1])
self.__aimMatrix.setTranslate(aimPoint)
return
def __multipositionSpawn(self, go, multivisualizer, influenceZone,
equipment, radius):
for zonePosition in influenceZone.zonesPosition:
localPosition = zonePosition - influenceZone.position
if multivisualizer.rotateFromCenter:
transform = math_utils.createRTMatrix(
(localPosition.yaw, 0, 0), localPosition)
else:
transform = math_utils.createTranslationMatrix(localPosition)
def postloadSetup(go):
areaVisualizer = go.findComponentByType(AreaAbilityVisualizer)
if areaVisualizer is not None:
areaVisualizer.radius = equipment.zoneRadius
eqComponent = go.createComponent(
InfluenceZoneEquipmentComponent)
eqComponent.setupEquipment(equipment)
return
CGF.loadGameObjectIntoHierarchy(multivisualizer.influencePrefab,
go, transform, postloadSetup)
def __addVehicleMarker(self, markerData, vehicleID, params, createMatrix=True):
vehicle = BigWorld.entities.get(vehicleID)
vehiclesMatrix = self._vehiclesAreaMarker['matrix']
positionData = params['positionData']
position = positionData['position']
ypr = positionData['ypr']
parent = self._parent
if createMatrix:
vehiclePrevData = self._vehiclesAreaMarker['prevData']
lastCheckTime = self._vehiclesAreaMarker['lastCheckTime']
if vehicle:
vehiclesMatrix.update({vehicleID: {'matrix': vehicle.matrix,
'inAoI': True}})
else:
vehiclesMatrix.update({vehicleID: {'matrix': math_utils.createRTMatrix(ypr, position),
'inAoI': False}})
vehiclePrevData.update({vehicleID: {'position': position,
'ypr': Math.Vector3(ypr)}})
lastCheckTime.update({vehicleID: BigWorld.time()})
marker = parent.createMarker(vehiclesMatrix[vehicleID]['matrix'], markerData['markerType'])
markerID = parent.addMarker(marker)
self._vehiclesAreaMarker['ID'].setdefault(vehicleID, {}).update({markerData['markerID']: markerID})
def _updateMatrix(self):
self._clampMinimalAimingRadius()
self._clampToArenaBB()
hitPoint = BigWorld.wg_collideSegment(
BigWorld.player().spaceID,
self._planePosition + Vector3(0.0, 1000.0, 0.0),
self._planePosition + Vector3(0.0, -250.0, 0.0), 128, 8)
aimPoint = Vector3(self._planePosition)
if hitPoint is not None:
aimPoint.y = hitPoint.closestPoint[1]
r0, v0, g0 = BigWorld.player().gunRotator.getShotParams(aimPoint, True)
hitPoint = BigWorld.wg_simulateProjectileTrajectory(
r0, v0, g0, SERVER_TICK_LENGTH, SHELL_TRAJECTORY_EPSILON_CLIENT,
128)
if hitPoint is not None:
time = (aimPoint.x - r0.x) / v0.x
self.__direction = v0 + g0 * time
self.__direction.normalise()
self._matrix = math_utils.createRTMatrix(
(self.__direction.yaw, -self.__direction.pitch, 0.0),
hitPoint[1])
self.__aimMatrix.setTranslate(aimPoint)
return
def __gunJointMat(self, turretMat, gunPitch, vehicleDescr):
gunShotOffset = self.gunShotOffset(vehicleDescr, self.__currentGun)
gunMat = math_utils.createRTMatrix(Vector3(0.0, gunPitch, 0.0), gunShotOffset)
gunMat.postMultiply(turretMat)
return gunMat
def __turretJointMat(self, vehicleMat, turretYaw, vehicleDescr):
turretOffset = self.turretOffset(vehicleDescr)
turretMat = math_utils.createRTMatrix(Vector3(turretYaw, 0.0, 0.0), turretOffset)
turretMat.postMultiply(vehicleMat)
return turretMat
def __updateCameraLocation(self):
position, yaw, pitch = self.__updateCalculateParams(self.__curTime)
mat = math_utils.createRTMatrix(Math.Vector3(yaw, pitch, 0.0),
position)
self.__camera.setWorldMatrix(mat)
self.__updateDynamicFOV(self.__curTime)
