def update(self, vehicle, deltaTime):
try:
curVelocity = vehicle.filter.velocity
acceleration = vehicle.filter.acceleration
acceleration = self.__accelerationFilter.add(acceleration)
movementFlags = vehicle.engineMode[1]
moveMask = 3
self.__hasChangedDirection = movementFlags & moveMask ^ self.__prevMovementFlags & moveMask or curVelocity.dot(
self.__prevVelocity) <= 0.01
self.__prevMovementFlags = movementFlags
self.__prevVelocity = curVelocity
self.__timeLapsedSinceDirChange += deltaTime
if self.__hasChangedDirection:
self.__timeLapsedSinceDirChange = 0.0
elif self.__timeLapsedSinceDirChange > self.__maxAccelerationDuration:
invVehMat = Matrix(vehicle.matrix)
invVehMat.invert()
accelerationRelativeToVehicle = invVehMat.applyVector(
acceleration)
accelerationRelativeToVehicle.x = 0.0
accelerationRelativeToVehicle.z = 0.0
acceleration = Matrix(
vehicle.matrix).applyVector(accelerationRelativeToVehicle)
self.__acceleration = acceleration
return acceleration
except:
return Math.Vector3(0.0, 0.0, 0.0)
def collideSegment(self, startPoint, endPoint, skipGun=False):
res = None
filterMethod = getattr(self.filter, 'segmentMayHitEntity',
lambda: True)
if not filterMethod(startPoint, endPoint, 0):
return res
else:
matricesToCheck = [Matrix(self.model.matrix)]
if not skipGun:
matricesToCheck.append(
Matrix(self.model.node(TankPartNames.GUN)))
for matrix, desc in zip(matricesToCheck, self.__componentsDesc):
toModel = matrix
toModel.invert()
collisions = desc.hitTester.localHitTest(
toModel.applyPoint(startPoint),
toModel.applyPoint(endPoint))
if collisions is None:
continue
for dist, _, hitAngleCos, matKind in collisions:
if res is None or res.dist >= dist:
matInfo = desc.materials.get(matKind)
res = SegmentCollisionResult(
dist, hitAngleCos,
matInfo.armor if matInfo is not None else 0)
return res
def __pickVehicle(self):
if self.__boundVehicleMProv is not None:
return
else:
x, y = GUI.mcursor().position
from AvatarInputHandler import cameras
dir, start = cameras.getWorldRayAndPoint(x, y)
end = start + dir.scale(100000.0)
pos, colldata = collideDynamicAndStatic(start, end, (), 0)
vehicle = None
if colldata is not None:
entity = colldata[0]
from Vehicle import Vehicle
if isinstance(entity, Vehicle):
vehMatProv = entity.matrix
vehMatInv = Matrix(vehMatProv)
vehMatInv.invert()
localPos = vehMatInv.applyPoint(pos)
result = Math.MatrixProduct()
localTransMat = Matrix()
localTransMat.translation = localPos
result.a = localTransMat
result.b = vehMatProv
return result
return
def createSRTMatrix(scale, rotation, translation):
scaleMatrix = Matrix()
scaleMatrix.setScale(scale)
result = Matrix()
result.setRotateYPR(rotation)
result.translation = translation
result.preMultiply(scaleMatrix)
return result
def decodeHitPoints(encodedPoints, collisionComponent):
resultPoints = []
maxHitEffectCode = None
maxDamagedComponentName = None
for encodedPoint in encodedPoints:
compIdx, hitEffectCode, startPoint, endPoint = DamageFromShotDecoder.decodeSegment(
encodedPoint, collisionComponent)
if startPoint == endPoint or compIdx < 0:
continue
if hitEffectCode > maxHitEffectCode:
maxHitEffectCode = hitEffectCode
maxDamagedComponentName = TankPartIndexes.getName(compIdx)
hitTestRes = collisionComponent.collideLocal(
compIdx, startPoint, endPoint)
bbox = collisionComponent.getBoundingBox(compIdx)
if not hitTestRes or hitTestRes < 0.0:
width, height, depth = (bbox[1] - bbox[0]) / 256.0
directions = [
Math.Vector3(0.0, -height, 0.0),
Math.Vector3(0.0, height, 0.0),
Math.Vector3(-width, 0.0, 0.0),
Math.Vector3(width, 0.0, 0.0),
Math.Vector3(0.0, 0.0, -depth),
Math.Vector3(0.0, 0.0, depth)
]
for direction in directions:
hitTestRes = collisionComponent.collideLocal(
compIdx, startPoint + direction, endPoint + direction)
if hitTestRes >= 0.0:
break
if hitTestRes is None or hitTestRes < 0.0:
newPoint = collisionComponent.collideLocalPoint(
compIdx, startPoint, MAX_FALLBACK_CHECK_DISTANCE)
if newPoint.length > 0.0:
hitRay = endPoint - startPoint
hitTestRes = hitRay.length
endPoint = newPoint
startPoint = endPoint - hitRay
if hitTestRes is None or hitTestRes < 0.0:
continue
minDist = hitTestRes
hitDir = endPoint - startPoint
hitDir.normalise()
rot = Matrix()
rot.setRotateYPR((hitDir.yaw, hitDir.pitch, 0.0))
matrix = Matrix()
matrix.setTranslate(startPoint + hitDir * minDist)
matrix.preMultiply(rot)
effectGroup = DamageFromShotDecoder.__hitEffectCodeToEffectGroup[
hitEffectCode]
componentName = TankPartIndexes.getName(compIdx)
resultPoints.append(
DamageFromShotDecoder.ShotPoint(componentName, matrix,
effectGroup))
return (maxHitEffectCode, resultPoints, maxDamagedComponentName)
def __switchBind(self):
if self.__basisMProv.isBound:
self.__basisMProv.bind(None)
else:
self.__basisMProv.bind(*self.__entityPicker.pick())
localMat = Matrix(self._cam.invViewMatrix)
basisInv = Matrix(self.__basisMProv.matrix)
basisInv.invert()
localMat.postMultiply(basisInv)
self.__position = localMat.translation
self.__ypr.set(localMat.yaw, localMat.pitch, localMat.roll)
return
def decodeHitPoints(encodedPoints, vehicleDescr):
resultPoints = []
maxHitEffectCode = None
maxDamagedComponentName = None
for encodedPoint in encodedPoints:
compName, hitEffectCode, startPoint, endPoint = DamageFromShotDecoder.decodeSegment(
encodedPoint, vehicleDescr)
if startPoint == endPoint:
continue
if hitEffectCode > maxHitEffectCode:
maxHitEffectCode = hitEffectCode
maxDamagedComponentName = compName
hitTester = getattr(vehicleDescr, compName).hitTester
hitTestRes = hitTester.localHitTest(startPoint, endPoint)
if not hitTestRes:
width, height, depth = (hitTester.bbox[1] -
hitTester.bbox[0]) / 256.0
directions = [
Math.Vector3(0.0, -height, 0.0),
Math.Vector3(0.0, height, 0.0),
Math.Vector3(-width, 0.0, 0.0),
Math.Vector3(width, 0.0, 0.0),
Math.Vector3(0.0, 0.0, -depth),
Math.Vector3(0.0, 0.0, depth)
]
for direction in directions:
hitTestRes = hitTester.localHitTest(
startPoint + direction, endPoint + direction)
if hitTestRes is not None:
break
if hitTestRes is None:
continue
minDist = hitTestRes[0][0]
for i in xrange(1, len(hitTestRes)):
dist = hitTestRes[i][0]
if dist < minDist:
minDist = dist
hitDir = endPoint - startPoint
hitDir.normalise()
rot = Matrix()
rot.setRotateYPR((hitDir.yaw, hitDir.pitch, 0.0))
matrix = Matrix()
matrix.setTranslate(startPoint + hitDir * minDist)
matrix.preMultiply(rot)
effectGroup = DamageFromShotDecoder.__hitEffectCodeToEffectGroup[
hitEffectCode]
resultPoints.append(
DamageFromShotDecoder.ShotPoint(compName, matrix, effectGroup))
return (maxHitEffectCode, resultPoints, maxDamagedComponentName)
def _getTurretYawGunPitch(self, targetPos, compensateGravity=False):
vehicleMatrix = Matrix(self._vehicleMProv)
turretOffset = GunMatCalc.turretOffset(self._vehicleTypeDescriptor)
gunShotOffset = GunMatCalc.gunShotOffset(self._vehicleTypeDescriptor, self.__gunIndex)
speed = self._vehicleTypeDescriptor.shot.speed
gravity = self._vehicleTypeDescriptor.shot.gravity if not compensateGravity else 0.0
turretYaw, gunPitch = BigWorld.wg_getShotAngles(turretOffset, gunShotOffset, vehicleMatrix, speed, gravity, 0.0, 0.0, targetPos, False)
rotation = math_utils.createRotationMatrix((turretYaw, gunPitch, 0.0))
rotation.postMultiply(vehicleMatrix)
invertSteady = Matrix(self._vehicleMProv)
invertSteady.invert()
rotation.postMultiply(invertSteady)
return (rotation.yaw, rotation.pitch)
def fireballTripTime(source, target, srcoff=Vector3(0, 1.5, 0), dstoff=Vector3(0, 1.2, 0)):
global projectileSpeed
if hasattr(target, 'matrix'):
targetMatrix = target.matrix
else:
targetMatrix = target
sourcePosition = Vector3(source.position) + srcoff
targetPosition = Vector3(Matrix(targetMatrix).applyToOrigin()) + dstoff
speed = projectileSpeed
tripTime = calculateTripTime(sourcePosition, targetPosition, speed)
if tripTime == 0:
speed = speed * 2.0
tripTime = calculateTripTime(sourcePosition, targetPosition, speed)
if tripTime == 0:
speed = speed * 2.0
tripTime = calculateTripTime(sourcePosition, targetPosition, speed)
if tripTime == 0:
speed = speed * 2.0
tripTime = calculateTripTime(sourcePosition, targetPosition, speed)
if tripTime == 0:
speed = speed * 2.0
tripTime = calculateTripTime(sourcePosition, targetPosition, speed)
if tripTime == 0:
print 'No speed solution for fireball'
return 0
return tripTime
def setControlMtx(self, mtx):
translation = Matrix()
translation.translation = Vector3(0, 0,
BigWorld.player().reductionPoint)
self._controlMtx = MatrixProduct()
self._controlMtx.b = mtx
self._controlMtx.a = translation
def MatrixCallback(self):
matr = self.ui.MatrixIn.toPlainText()
matr = str(matr).split()
matr = [float(element) for element in matr]
dt = self.ui.DTIn.text()
dt = str(dt).split(" ")
dt = [float(element) for element in dt]
if sqrt(len(matr)) - int(sqrt(len(matr))) != 0 or matr[0] == '':
self.ui.textBrowser.append(
"Girilen matris kare ve bos olmayan bir matris olmalidir.")
return
matr = Matrix(int(sqrt(len(matr))), matr)
try:
if self.ui.radioMatrix.isChecked():
self.ui.textBrowser.append("Cozum takimi : " +
str(matr.gaussElimination(dt)))
elif self.ui.radioMatrix2.isChecked():
self.ui.textBrowser.append("Invers Matris :")
for row in matr.inverse().matrix:
self.ui.textBrowser.append(str(row))
elif self.ui.radioMatrix3.isChecked():
self.ui.textBrowser.append("Determinant : " +
str(matr.determinant()))
except Exception as exc:
self.ui.textBrowser.append(exc.args[0])
def __update(self, dx, dy, dz, rotateMode = True, zoomMode = True, isCallback = False):
prevPos = self.__inputInertia.calcWorldPos(self.__aimingSystem.matrix)
distChanged = False
if zoomMode and dz != 0:
prevDist = self.__aimingSystem.distanceFromFocus
distDelta = dz * float(self.__curScrollSense)
distMinMax = self.__cfg['distRange']
newDist = mathUtils.clamp(distMinMax.min, distMinMax.max, prevDist - distDelta)
if abs(newDist - prevDist) > 0.001:
self.__aimingSystem.distanceFromFocus = newDist
self.__userCfg['startDist'] = newDist
self.__inputInertia.glideFov(self.__calcRelativeDist())
self.__aimingSystem.aimMatrix = self.__calcAimMatrix()
distChanged = True
changeControlMode = prevDist == newDist and mathUtils.almostZero(newDist - distMinMax.min)
if changeControlMode and self.__onChangeControlMode is not None:
self.__onChangeControlMode()
return
if rotateMode:
self.__updateAngles(dx, dy)
if ENABLE_INPUT_ROTATION_INERTIA and not distChanged:
self.__aimingSystem.update(0.0)
if ENABLE_INPUT_ROTATION_INERTIA or distChanged:
worldDeltaPos = prevPos - self.__aimingSystem.matrix.translation
matInv = Matrix(self.__aimingSystem.matrix)
matInv.invert()
self.__inputInertia.glide(matInv.applyVector(worldDeltaPos))
def update(self, deltaTime):
self.__oscillator.constraints = mathUtils.matrixScale(
self.__yprDeviationConstraints,
SniperAimingSystem.__CONSTRAINTS_MULTIPLIERS)
vehicleMat = Matrix(self.__vehicleMProv)
curTurretYaw, curGunPitch = self.__worldYawPitchToTurret(
self.__worldYaw, self.__worldPitch)
yprDelta = Vector3(curTurretYaw - self.__idealTurretYaw,
curGunPitch - self.__idealGunPitch, 0)
self.__oscillator.deviation = yprDelta
self.__oscillator.update(deltaTime)
curTurretYaw = self.__idealTurretYaw + self.__oscillator.deviation.x
curGunPitch = self.__idealGunPitch + self.__oscillator.deviation.y
curTurretYaw, curGunPitch = self.__clampToLimits(
curTurretYaw, curGunPitch)
yprDelta = Vector3(curTurretYaw - self.__idealTurretYaw,
curGunPitch - self.__idealGunPitch, 0)
self.__oscillator.deviation = yprDelta
currentGunMat = AimingSystems.getPlayerGunMat(curTurretYaw,
curGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__vehiclePrevMat = vehicleMat
return 0.0
def __init__(self):
self.__flagModel = None
self.__flagFashion = None
self.__flagScaleMatrix = Matrix()
self.__flagStaffModel = None
self.__flagStaffFashion = None
return
def enable(self, targetPos):
player = BigWorld.player()
self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor
self.__vehicleMProv = player.getOwnVehicleMatrix()
self.__vehiclePrevMat = Matrix(self.__vehicleMProv)
IAimingSystem.enable(self, targetPos)
self.__yawLimits = self.__vehicleTypeDescriptor.gun['turretYawLimits']
self.__pitchLimits = self.__vehicleTypeDescriptor.gun['pitchLimits']
self.__idealYaw, self.__idealPitch = getShotAngles(
self.__vehicleTypeDescriptor, player.getOwnVehicleMatrix(),
(0.0, 0.0), targetPos, False)
self.__idealYaw, self.__idealPitch = self.__clampToLimits(
self.__idealYaw, self.__idealPitch)
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw,
self.__idealPitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = (targetPos - currentGunMat.translation).pitch
self._matrix.set(currentGunMat)
self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(
self.__g_curYaw, self.__g_curPitch)
self.__idealYaw, self.__idealPitch = self.__clampToLimits(
self.__idealYaw, self.__idealPitch)
self.__oscillator.reset()
self.__pitchfilter.reset(currentGunMat.pitch)
SniperAimingSystem.__activeSystem = self
def __update(self):
self.__updateCallbackId = None
self.__updateCallbackId = BigWorld.callback(0.0, self.__update)
curTime = BigWorld.time()
dt = curTime - self.__prevTime
self.__prevTime = curTime
self.__currentAngle += self.__angularVelocity * dt
if self.__currentAngle > 2 * math.pi:
self.__currentAngle -= 2 * math.pi
elif self.__currentAngle < -2 * math.pi:
self.__currentAngle += 2 * math.pi
radialPosition = Vector3(self.radius * math.sin(self.__currentAngle),
0,
self.radius * math.cos(self.__currentAngle))
modelYaw = self.__currentAngle
if self.rotateClockwise:
modelYaw += math.pi / 2
else:
modelYaw -= math.pi / 2
localMatrix = Matrix()
localMatrix.setRotateY(modelYaw)
localMatrix.translation = radialPosition
self.__modelMatrix.setRotateYPR((self.yaw, self.pitch, self.roll))
self.__modelMatrix.translation = self.position
self.__modelMatrix.preMultiply(localMatrix)
return
def create(self, onChangeControlMode=None):
self.__onChangeControlMode = onChangeControlMode
aimingSystemClass = ArtyAimingSystemRemote if BigWorld.player().isObserver() else ArtyAimingSystem
self.__aimingSystem = aimingSystemClass()
self.__camDist = self.__cfg['camDist']
self.__desiredCamDist = self.__camDist
self.__positionHysteresis = PositionHysteresis(self.__cfg['hPositionThresholdSq'])
self.__timeHysteresis = TimeHysteresis(self.__cfg['hTimeThreshold'])
self.__cam.pivotMaxDist = 0.0
self.__cam.maxDistHalfLife = 0.01
self.__cam.movementHalfLife = 0.0
self.__cam.turningHalfLife = -1
self.__cam.pivotPosition = Vector3(0.0, 0.0, 0.0)
self.__sourceMatrix = Matrix()
self.__targetMatrix = Matrix()
self.__rotation = 0.0
def __calcCurOscillatorAcceleration(self, deltaTime):
vehicle = BigWorld.player().vehicle
if vehicle is None or not vehicle.isAlive():
return Vector3(0, 0, 0)
else:
curVelocity = vehicle.filter.velocity
relativeSpeed = curVelocity.length / vehicle.typeDescriptor.physics[
'speedLimits'][0]
if relativeSpeed >= SniperCamera._MIN_REL_SPEED_ACC_SMOOTHING:
self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg[
'accelerationThreshold']
else:
self.__accelerationSmoother.maxAllowedAcceleration = self.__dynamicCfg[
'accelerationMax']
acceleration = self.__accelerationSmoother.update(
vehicle, deltaTime)
camMat = Matrix(self.__cam.matrix)
acceleration = camMat.applyVector(-acceleration)
accelSensitivity = self.__dynamicCfg['accelerationSensitivity']
acceleration.x *= accelSensitivity.x
acceleration.y *= accelSensitivity.y
acceleration.z *= accelSensitivity.z
oscillatorAcceleration = Vector3(0,
-acceleration.y + acceleration.z,
-acceleration.x)
return oscillatorAcceleration
def __onResourcesLoaded(self, resourceRefs):
if self.guid not in BigWorld.userDataObjects:
return
else:
self.__clear()
if self.modelName in resourceRefs.failedIDs:
return
try:
self.__model = resourceRefs[self.modelName]
self.__modelMatrix = Matrix()
self.__modelMatrix.setIdentity()
servo = BigWorld.Servo(self.__modelMatrix)
self.__model.addMotor(servo)
BigWorld.addModel(self.__model)
if self.actionName != '':
action = self.__model.action(self.actionName)
if action is not None:
action()
if self.pixieName != '' and self.pixieName not in resourceRefs.failedIDs:
pixieNode = self.__model.node(self.pixieHardPoint)
pixieNode.attach(resourceRefs[self.pixieName])
if self.soundName != '':
self.__sound = SoundGroups.g_instance.getSound3D(
self.__modelMatrix, self.soundName)
except:
LOG_CURRENT_EXCEPTION()
self.__model = None
return
self.__prevTime = BigWorld.time()
self.__update()
return
def enable(self, targetPos):
player = BigWorld.player()
self.__vehicleTypeDescriptor = player.vehicleTypeDescriptor
self.__vehicleMProv = player.getOwnVehicleStabilisedMatrix()
self.__vehiclePrevMat = Matrix(self.__vehicleMProv)
IAimingSystem.enable(self, targetPos)
self.__yawLimits = self.__vehicleTypeDescriptor.gun['turretYawLimits']
self.__pitchLimits = self.__vehicleTypeDescriptor.gun['pitchLimits']
self.__idealYaw, self.__idealPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleTypeDescriptor, self.__vehicleMProv, targetPos, True)
self.__idealYaw, self.__idealPitch = self.__clampToLimits(self.__idealYaw, self.__idealPitch)
currentGunMat = AimingSystems.getPlayerGunMat(self.__idealYaw, self.__idealPitch)
self.__g_curYaw = currentGunMat.yaw
self.__g_curPitch = (targetPos - currentGunMat.translation).pitch
self._matrix.set(currentGunMat)
self.__idealYaw, self.__idealPitch = self.__worldYawPitchToTurret(self.__g_curYaw, self.__g_curPitch)
self.__idealYaw, self.__idealPitch = self.__clampToLimits(self.__idealYaw, self.__idealPitch)
self.__oscillator.reset()
self.__pitchfilter.reset(currentGunMat.pitch)
SniperAimingSystem.__activeSystem = self
vehicle = player.getVehicleAttached()
if vehicle is not None:
if hasattr(vehicle.filter, 'placingOnGround') and not vehicle.filter.placingOnGround:
vehicle.filter.calcPlacedMatrix(True)
self.__baseMatrix = vehicle.filter.placingMatrix
else:
self.__baseMatrix = vehicle.matrix
return
def __onDebugInfoReceived(self, argStr):
from Math import Matrix, Vector3
positions = wgPickle.loads(wgPickle.FromServerToClient, argStr)
for planeID, pos in positions:
m = Matrix()
m.setTranslate(pos)
BigWorld.addPoint('spawnPoint%d' % planeID, m, 4278190335L, False)
def shootProjectile(owner,
target,
projectile,
trail=None,
boom=None,
srcoff=Vector3(0, 1.5, 0),
dstoff=Vector3(0, 1.2, 0),
motor=None):
if hasattr(target, 'matrix'):
targetMatrix = target.matrix
else:
targetMatrix = target
if not boom and dstoff:
dstoff.y = 1.8
if not dstoff:
dstoff = Vector3(0, 0, 0)
owner.addModel(projectile)
projectile.position = Vector3(owner.position) + srcoff
if not motor:
motor = BigWorld.Homer()
motor.speed = projectileSpeed
motor.turnRate = 10
if dstoff.lengthSquared == 0:
motor.target = targetMatrix
else:
motor.target = MatrixProduct()
motor.target.a = targetMatrix
motor.target.b = Matrix()
motor.target.b.setTranslate(dstoff)
if motor.tripTime <= 0.0:
sourcePosition = Vector3(owner.position) + srcoff
targetPosition = Vector3(Matrix(targetMatrix).applyToOrigin()) + dstoff
speed = motor.speed
t = calculateTripTime(sourcePosition, targetPosition, speed)
if t == 0:
owner.delModel(projectile)
return 0
motor.tripTime = t
projectile.addMotor(motor)
if trail:
trail(projectile, None, motor.tripTime)
motor.proximity = 1.0
if boom:
motor.proximityCallback = boom
else:
motor.proximityCallback = partial(owner.delModel, projectile)
return motor.tripTime
def focusOnPos(self, preferredPos):
vehPos = Matrix(self.__vehicleMProv).translation
posOnVehicle = vehPos + Vector3(0.0, self.__cursor.heightAboveBase, 0.0)
self.yaw = (preferredPos - vehPos).yaw
xzDir = Vector3(self.__cursor.focusRadius * math.sin(self.__cursor.yaw), 0.0, self.__cursor.focusRadius * math.cos(self.__cursor.yaw))
pivotPos = posOnVehicle + xzDir
self.pitch = self.__calcPitchAngle(self.__cursor.distanceFromFocus, preferredPos - pivotPos)
self.__updateInternal()
def __getMarkerMatrix(self, destructibleEntity):
guiNode = destructibleEntity.getGuiNode()
if guiNode is not None:
return guiNode
else:
m = Matrix()
m.translation = destructibleEntity.position + settings.MARKER_POSITION_ADJUSTMENT
return m
def __calcAimOffset(self, aimLocalTransform=None):
aimingSystemMatrix = self.__aimingSystem.matrix
worldCrosshair = Matrix(self.__crosshairMatrix)
if aimLocalTransform is not None:
worldCrosshair.postMultiply(aimLocalTransform)
worldCrosshair.postMultiply(aimingSystemMatrix)
aimOffset = cameras.projectPoint(worldCrosshair.translation)
return Vector2(math_utils.clamp(-0.95, 0.95, aimOffset.x), math_utils.clamp(-0.95, 0.95, aimOffset.y))
def __getLookAtYPR(self, lookAtPosition):
lookDir = lookAtPosition - self.__position
camMat = Matrix()
camMat.lookAt(self.__position, lookDir, Vector3(0, 1, 0))
camMat.invert()
yaw = camMat.yaw
pitch = camMat.pitch
return Vector3(yaw, pitch, self.__ypr.z)
def update(self):
global printedVehicle
self.vehicle = BigWorld.entity(self.vehicleID)
if self.vehicle is not None:
if self.vehicle.health > 0 and self.vehicle.isAlive():
self.isAlive = True
if self.isAlive is False or self.vehicle is None or (self.vehicle is not None and self.vehicle.health <= 0):
print('[predictAim] enemy died or does not exists')
self.hideVisible()
return
if not hasattr(BigWorld.player(), 'vehicleTypeDescriptor') or not hasattr(BigWorld.player(), 'gunRotator') or (hasattr(self.vehicle,"health") and self.vehicle.health <= 0):
print('[predictAim] player has no vehicleTypeDescriptor or gunRotator OR enemy is has no health or health is lower/same as zero')
self.hideVisible()
return
if self.modelDot is not None and self.modelDot._StaticObjectMarker3D__model:
playerVehicleID = BigWorld.player().playerVehicleID
if playerVehicleID:
playerVehicle = BigWorld.entity(playerVehicleID)
playerPosition = playerVehicle.model.node("hull").position
self.vehicle = BigWorld.entity(self.vehicleID)
shotSpeed = BigWorld.player().vehicleTypeDescriptor.shot.speed
distance = playerPosition.flatDistTo(self.vehicle.model.node("hull").position)
traveltime = distance / shotSpeed
enemyCurrentSpeed = self.vehicle.speedInfo.value
if self.lastSpeedValue is None or self.lastSpeedValue is enemyCurrentSpeed:
self.lastSpeedValue = enemyCurrentSpeed
enemyCurrentSpeed = (enemyCurrentSpeed + self.lastSpeedValue) / 2
self.lastSpeedValue = enemyCurrentSpeed
centerFront = self.vehicle.model.node("hull").position
cMin , cMax , _ = self.vehicle.getBounds(TankPartIndexes.CHASSIS)
_ , hMax , _ = self.vehicle.getBounds(TankPartIndexes.HULL)
hMax.y += cMax.y
_ , tMax , _ =self.vehicle.getBounds(TankPartIndexes.TURRET)
tMax.y += hMax.y
cMax.y = tMax.y
matrix = Matrix(self.vehicle.matrix)
FRONT_RIGTH_BOTTOM = matrix.applyVector(Vector3(cMax.x , cMin.y , cMax.z )) + self.vehicle.position
FRONT_LEFT_BOTTOM = matrix.applyVector(Vector3(cMin.x , cMin.y , cMax.z )) + self.vehicle.position
centerFront = (FRONT_RIGTH_BOTTOM + FRONT_LEFT_BOTTOM)/2
#print("[predictAim]: center Front pos: %s" % centerFront)
#print("[predictAim]: hull: %s" % self.vehicle.model.node("hull").position)
#print("[predictAim]: center Back pos: %s" % centerBack)
travel_distance_0 = enemyCurrentSpeed[0] * traveltime
#travel_distance_2 = enemyCurrentSpeed[2] * traveltime
v = centerFront - self.vehicle.model.node("hull").position
v3 = Vector3(v)
#v3.normalise()
predPos_test = self.vehicle.model.node("hull").position + (v3*travel_distance_0)
tmp_veh = BigWorld.entity(self.vehicleID)
predPos_test[1] = tmp_veh.model.node("hull").position[1]
self.modelDot._StaticObjectMarker3D__model.position = predPos_test
self.modelDot._StaticObjectMarker3D__model.visible = True
def __getModel(self, modelName):
if self.reuseModels[modelName]:
model, motor = self.reuseModels[modelName].pop()
else:
model = BigWorld.Model(modelName)
motor = BigWorld.Servo(Matrix())
model.addMotor(motor)
BigWorld.addModel(model, self.spaceID)
return (model, motor)
def intersect(self,line):
try:
ts = Matrix(self.vector,line.vector).inverse_ip().vector_mult(line.start-self.start)
if ts[0]<0 and ts[0]>-1 and ts[1]>0 and ts[1]<1:
a = self.start+self.vector*ts[0]
return a
except: #Matrix is not invertable => lines are Parallell => no intersection
pass
return False
def __calculateAimOffset(self, aimWorldPos):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
else:
proj = BigWorld.projection()
aimLocalPos = Matrix(self.__cam.matrix).applyPoint(aimWorldPos)
if aimLocalPos.z < 0:
aimLocalPos.z = max(0.0,
proj.nearPlane - _OFFSET_FROM_NEAR_PLANE)
aimWorldPos = Matrix(
self.__cam.invViewMatrix).applyPoint(aimLocalPos)
aimOffset = cameras.projectPoint(aimWorldPos)
aimOffset = Vector2(math_utils.clamp(-0.95, 0.95, aimOffset.x),
math_utils.clamp(-0.95, 0.95, aimOffset.y))
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
return aimOffset
