def rotationMatrix(self): w = self.target.normalize() u = Vector3.cross(Vector3.up().normalize(), w) v = Vector3.cross(w, u) rotMat = np.matrix([[u.x, u.y, u.z, 0.0], [v.x, v.y, v.z, 0.0], [w.x, w.y, w.z, 0.0 ], [0.0, 0.0, 0.0, 1.0]], dtype=np.float32) return rotMat
def mouseMove(self, x, y): newMouse = Vector2(x, y) delta = (newMouse - self.mouse).normalize() self.mouse = newMouse if delta.x > 0: self.camera.position -= Vector3.cross(self.camera.up.normalize(),self.camera.target.normalize()) * delta.x * self.PAN_MOVE else: self.camera.position += Vector3.cross(self.camera.up.normalize(),self.camera.target.normalize()) * abs(delta.x) * self.PAN_MOVE if delta.y < 0: self.camera.position -= self.camera.up.normalize() * abs(delta.y) * self.PAN_MOVE else: self.camera.position += self.camera.up.normalize() * delta.y *self.PAN_MOVE print delta
def __init__(self, width=None, height=None): self.position = Vector3() self.target = Vector3(0.0, 0.0, 1.0) self.up = Vector3.up() self.width = width self.height = height self.aspectRatio = None
def getDesiredShotPoint(self, scanStart, scanDir):
scanPos, isPointConvenient = self.__testMouseTargetPoint(scanStart, scanDir)
if isPointConvenient:
return scanPos
planePos = self.__aimPlane.intersectRay(scanStart, scanDir)
if scanStart.distSqrTo(planePos) < scanStart.distSqrTo(scanPos):
return scanPos
turretYaw, gunPitch = AimingSystems.getTurretYawGunPitch(self.__vehicleDesc, self.__vehicleMat, planePos, True)
gunMat = AimingSystems.getGunJointMat(self.__vehicleDesc, self.__getTurretMat(turretYaw), gunPitch)
aimDir = gunMat.applyVector(Vector3(0.0, 0.0, 1.0))
shotDistance = self.__vehicleDesc.shot.maxDistance
return AimingSystems.getDesiredShotPoint(gunMat.translation, aimDir, shotDistance=shotDistance)
def getVehiclePointsGen(vehicle):
vehicleDesr = vehicle.typeDescriptor
hullPos = vehicleDesr.chassis.hullPosition
hullBboxMin, hullBboxMax, _ = vehicleDesr.hull.hitTester.bbox
turretPosOnHull = vehicleDesr.hull.turretPositions[0]
turretLocalTopY = max(
hullBboxMax.y,
turretPosOnHull.y + vehicleDesr.turret.hitTester.bbox[1].y)
yield Vector3(0.0, hullPos.y + turretLocalTopY, 0.0)
gunPosOnHull = turretPosOnHull + vehicleDesr.turret.gunPosition
yield hullPos + gunPosOnHull
hullLocalCenterY = (hullBboxMin.y + hullBboxMax.y) / 2.0
hullLocalPt1 = Vector3(0.0, hullLocalCenterY, hullBboxMax.z)
yield hullPos + hullLocalPt1
hullLocalPt2 = Vector3(0.0, hullLocalCenterY, hullBboxMin.z)
yield hullPos + hullLocalPt2
hullLocalCenterZ = (hullBboxMin.z + hullBboxMax.z) / 2.0
hullLocalPt3 = Vector3(hullBboxMax.x, gunPosOnHull.y, hullLocalCenterZ)
yield hullPos + hullLocalPt3
hullLocalPt4 = Vector3(hullBboxMin.x, gunPosOnHull.y, hullLocalCenterZ)
yield hullPos + hullLocalPt4
def __getCollisionTestOrigin(self, aimPoint, direction):
distRange = self.__cfg['distRange']
vehiclePosition = BigWorld.player().getVehicleAttached().position
collisionTestOrigin = Vector3(vehiclePosition)
if direction.x * direction.x > direction.z * direction.z and not mathUtils.almostZero(direction.x):
collisionTestOrigin.y = direction.y / direction.x * (vehiclePosition.x - aimPoint.x) + aimPoint.y
elif not mathUtils.almostZero(direction.z):
collisionTestOrigin.y = direction.y / direction.z * (vehiclePosition.z - aimPoint.z) + aimPoint.y
else:
collisionTestOrigin = aimPoint - direction.scale((distRange[1] - distRange[0]) / 2.0)
LOG_WARNING("Can't find point on direction ray. Using half point as collision test origin")
return collisionTestOrigin
def processHover(self, position, force=False):
if force:
position = AimingSystems.getDesiredShotPoint(
Math.Vector3(position[0], 500.0, position[2]),
Math.Vector3(0.0, -1.0, 0.0), True, True, True)
self.__marker.setPosition(position)
BigWorld.callback(SERVER_TICK_LENGTH, self.__markerForceUpdate)
else:
self.__marker.update(position, Vector3(0, 0, 1), 10,
SERVER_TICK_LENGTH, None)
self.hitPosition = position
self.writeStateToReplay()
def disable(self):
if not self.__isEnabled:
return
self.__isEnabled = False
self.__cam.disable()
self.__activeSelector.destroy()
self.__activeSelector = _DefaultStrikeSelector(Vector3(0, 0, 0), None)
self.setGUIVisible(False)
g_postProcessing.disable()
BigWorld.setFloraEnabled(True)
if BigWorld.player().gunRotator is not None:
BigWorld.player().gunRotator.clientMode = True
def __createDirectedLine(self, pointA, pointB, width):
modelName = self.CUBE_MODEL
model, motor = self.__getModel(modelName)
direction = pointB - pointA
scale = (width, width, direction.length)
rotation = (direction.yaw, direction.pitch, 0)
translation = pointA + direction * 0.5
m = math_utils.createSRTMatrix(scale, rotation, translation)
m.preMultiply(
math_utils.createTranslationMatrix(Vector3(0.0, -0.5, 0.0)))
motor.signal = m
return (modelName, model, motor)
def initSettings(self, settings):
self.flagModelName = settings.readString('flagModelName', '')
self.flagStaffModelName = settings.readString('flagstaffModelName', '')
self.radiusModel = settings.readString('radiusModel', '')
self.flagAnim = settings.readString('flagAnim', '')
self.flagStaffFlagHP = settings.readString('flagstaffFlagHP', '')
self.baseAttachedSoundEventName = settings.readString('wwsound', '')
self.flagBackgroundTex = settings.readString('flagBackgroundTex', '')
self.flagEmblemTex = settings.readString('flagEmblemTex', '')
self.flagEmblemTexCoords = settings.readVector4('flagEmblemTexCoords', Vector4())
self.flagScale = settings.readVector3('flagScale', Vector3())
self.flagNodeAliasName = settings.readString('flagNodeAliasName', '')
def applyImpulse(self, position, impulse, reason=ImpulseReason.ME_HIT):
adjustedImpulse, noiseMagnitude = self.__dynamicCfg.adjustImpulse(
impulse, reason)
camMatrix = Matrix(self.__cam.matrix)
impulseLocal = camMatrix.applyVector(adjustedImpulse)
impulseAsYPR = Vector3(impulseLocal.x,
-impulseLocal.y + impulseLocal.z, 0)
rollPart = self.__dynamicCfg['impulsePartToRoll']
impulseAsYPR.z = -rollPart * impulseAsYPR.x
impulseAsYPR.x *= 1 - rollPart
self.__impulseOscillator.applyImpulse(impulseAsYPR)
self.__applyNoiseImpulse(noiseMagnitude)
def __init__(self, position, isVisible, flagID):
position = Vector3(0.0, 0.0, 0.0) if position is None else position
self.__flagEntity = None
self.__position = position
self.__isVisible = isVisible
self.__flagID = flagID
spaceId = BigWorld.player().spaceID
if spaceId != 0:
self.create()
else:
g_ctfManager.addDelayedFlag(self)
return
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 __updateOscillators(self, deltaTime):
if not SniperCamera.isCameraDynamic():
self.__impulseOscillator.reset()
self.__movementOscillator.reset()
self.__noiseOscillator.reset()
return (math_utils.createRotationMatrix(Vector3(0, 0, 0)), math_utils.createRotationMatrix(Vector3(0, 0, 0)))
oscillatorAcceleration = self.__calcCurOscillatorAcceleration(deltaTime)
self.__movementOscillator.externalForce += oscillatorAcceleration
self.__impulseOscillator.update(deltaTime)
self.__movementOscillator.update(deltaTime)
self.__noiseOscillator.update(deltaTime)
noiseDeviation = Vector3(self.__noiseOscillator.deviation)
deviation = self.__impulseOscillator.deviation + self.__movementOscillator.deviation + noiseDeviation
oscVelocity = self.__impulseOscillator.velocity + self.__movementOscillator.velocity + self.__noiseOscillator.velocity
if abs(deviation.x) < 1e-05 and abs(oscVelocity.x) < 0.0001:
deviation.x = 0
if abs(deviation.y) < 1e-05 and abs(oscVelocity.y) < 0.0001:
deviation.y = 0
if abs(deviation.z) < 1e-05 and abs(oscVelocity.z) < 0.0001:
deviation.z = 0
curZoomIdx = 0
zooms = self._cfg['zooms']
for idx in xrange(len(zooms)):
if self.__zoom == zooms[idx]:
curZoomIdx = idx
break
zoomExposure = self.__zoom * self.__dynamicCfg['zoomExposure'][curZoomIdx]
deviation /= zoomExposure
impulseDeviation = (self.__impulseOscillator.deviation + noiseDeviation) / zoomExposure
self.__impulseOscillator.externalForce = Vector3(0)
self.__movementOscillator.externalForce = Vector3(0)
self.__noiseOscillator.externalForce = Vector3(0)
return (math_utils.createRotationMatrix(Vector3(deviation.x, deviation.y, deviation.z)), math_utils.createRotationMatrix(impulseDeviation))
def __generateRetreatTrajectory(self, idealFlightHeight,
bombingEndPosition, bombingDir,
bombingEndTime):
clientArena = BigWorld.player().arena
endTrajectoryPosition = clientArena.collideWithSpaceBB(
bombingEndPosition, bombingEndPosition + bombingDir * 9000.0)
segmentLength = (endTrajectoryPosition - bombingEndPosition
).length / _RETREAT_SUBDIVISION_FACTOR
firstRetreatPoint = Vector3(bombingEndPosition +
bombingDir * _INITIAL_RETREAT_SHIFT)
positions = [firstRetreatPoint]
positions += [
firstRetreatPoint + bombingDir * (segmentLength * (idx + 1))
for idx in xrange(_RETREAT_SUBDIVISION_FACTOR - 1)
]
positions.append(endTrajectoryPosition -
bombingDir * min(segmentLength * 0.1, 50.0))
positions.append(endTrajectoryPosition + bombingDir * 100)
retreatHeight = _MINIMAL_RETREAT_HEIGHT
minFlightHeight = idealFlightHeight
for position in positions:
zeroHeightPos = Vector3(position)
zeroHeightPos.y = 0
collRes = BigWorld.wg_collideSegment(BigWorld.player().spaceID,
zeroHeightPos + (0, 1000, 0),
zeroHeightPos + (0, -1000, 0),
18)
if collRes is not None:
minFlightHeight = max(collRes[0].y + retreatHeight,
minFlightHeight)
else:
minFlightHeight = max(position.y, minFlightHeight)
position.y = minFlightHeight
for idx in xrange(len(positions) - 1):
positions[idx].y = (positions[idx].y + positions[idx + 1].y) / 2.0
result = self.__generateRetreatPoints(bombingEndPosition,
bombingEndTime, positions)
return result
def __processBindToVehicleKey(self):
if BigWorld.isKeyDown(Keys.KEY_LSHIFT) or BigWorld.isKeyDown(Keys.KEY_RSHIFT):
self.__toggleView()
elif BigWorld.isKeyDown(Keys.KEY_LALT) or BigWorld.isKeyDown(Keys.KEY_RALT):
worldMat = Math.Matrix(self.__cam.invViewProvider)
self.__basisMProv.selectNextPlacement()
boundMatrixInv = Matrix(self.__basisMProv.matrix)
boundMatrixInv.invert()
worldMat.postMultiply(boundMatrixInv)
self.__position = worldMat.translation
self.__ypr = Vector3(worldMat.yaw, worldMat.pitch, worldMat.roll)
else:
self.__switchBind()
def checkCreate(self):
if self.tmpdata is None:
BigWorld.callback(1, self.checkCreate)
return
else:
for model in self.tmpdata:
yaw = model['yaw']
path = model['path']
bid = model['id']
pos = Vector3((model['x'], model['y'], model['z']))
self.data[bid] = MyModel(bid, pos, yaw, path)
return
def intersectRay(self,
startPos,
direction,
checkCloseness=True,
checkSign=True):
collisionPoint = self.__plane.intersectRay(startPos, direction)
projection = Vector3(0.0, 1.0, 0.0).dot(direction)
tooClose = collisionPoint.distTo(
startPos) - self.__lookLength < -0.0001 and checkCloseness
parallelToPlane = abs(projection) <= _AimPlane.__EPS_COLLIDE_ARENA
projectionSignDiffers = projection * self.__initialProjection < 0.0 and checkSign
backwardCollision = (collisionPoint - startPos).dot(direction) <= 0.0
return startPos + direction * self.__lookLength if tooClose or parallelToPlane or projectionSignDiffers or backwardCollision else collisionPoint
def __init__(self, dataSec):
IAimingSystem.__init__(self)
self.__idealTurretYaw = 0.0
self.__idealGunPitch = 0.0
self.__worldYaw = 0.0
self.__worldPitch = 0.0
self.__vehicleTypeDescriptor = None
self.__vehicleMProv = None
self.__yprDeviationConstraints = Vector3(
SniperAimingSystem.__STABILIZED_CONSTRAINTS)
self.__oscillator = Math.PyOscillator(1.0, Vector3(0.0, 0.0, 15.0),
Vector3(0.0, 0.0, 3.5),
self.__yprDeviationConstraints)
self.__returningOscillator = Math.PyOscillator(
1.0, Vector3(0.0, 15.0, 15.0), Vector3(0.0, 3.5, 3.5),
self.__yprDeviationConstraints)
self.__pitchCompensating = 0.0
self.__yawLimits = None
self.__forceFullStabilization = False
self.__timeBeyondLimits = 0.0
self.__playerGunMatFunction = AimingSystems.getPlayerGunMat
return
def exhibit(tankNames=None,
pivotPoint=None,
shift=Vector3(0, 0, 10),
assembler=assembleCompoundModel2):
if pivotPoint is None:
p = Vector3(BigWorld.camera().position)
d = BigWorld.camera().direction
spaceID = BigWorld.player().spaceID if BigWorld.player(
) is not None else BigWorld.camera().spaceID
collRes = BigWorld.wg_collideSegment(spaceID, p, p + d * 1000, 18, 8)
if collRes is None:
pivotPoint = Vector3(0, 0, 0)
else:
strikePos = collRes[0]
pivotPoint = strikePos
if tankNames is None:
tankNames = [
vehicles.g_cache.vehicle(0, x).name for x in xrange(EXAMPLE_COUNT)
]
totalTanks = len(tankNames)
shift_new = Vector3(d)
shift_new.y = 0.0
up = Vector3(0.0, 1.0, 0.0)
right = up * shift_new
shift_new.normalise()
right.normalise()
offset = 6.0
shift_new = shift_new * offset
right = right * offset
for idx, tankName in enumerate(tankNames):
desc = vehicles.VehicleDescr(typeName=tankName)
if idx < totalTanks / 2:
creationPosition = pivotPoint + shift_new * idx
else:
creationPosition = pivotPoint + shift_new * (
idx - totalTanks / 2) + right
assembler(getModelNames(desc), creationPosition, desc)
return
def _VehicleGunRotator__getGunMarkerPosition(base, self, shotPos, shotVec,
dispersionAngles):
if not (config.get('sight/enabled', True)
and battle.isBattleTypeSupported):
return base(self, shotPos, shotVec, dispersionAngles)
try:
global timeFlight, currentDistance, timeAIM, cameraHeight
shotDescr = player.getVehicleDescriptor().shot
gravity = Vector3(0.0, -shotDescr.gravity, 0.0)
testVehicleID = self.getAttachedVehicleID()
collisionStrategy = CollisionStrategy.COLLIDE_DYNAMIC_AND_STATIC
minBounds, maxBounds = player.arena.getSpaceBB()
endPos, direction, collData, usedMaxDistance = getCappedShotTargetInfos(
shotPos, shotVec, gravity, shotDescr, testVehicleID, minBounds,
maxBounds, collisionStrategy)
distance = shotDescr.maxDistance if usedMaxDistance else (
endPos - shotPos).length
dispersAngle, idealDispersAngle = dispersionAngles
doubleDistance = distance + distance
markerDiameter = doubleDistance * dispersAngle
idealMarkerDiameter = doubleDistance * idealDispersAngle
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isClientReady:
markerDiameter, endPos, direction = replayCtrl.getGunMarkerParams(
endPos, direction)
shotVecXZ = Vector2(shotVec.x, shotVec.z)
delta = Vector2(endPos.x - shotPos.x, endPos.z - shotPos.z)
timeFlight = delta.length / shotVecXZ.length
aimingStartTime, aimingFactor, shotDispMultiplierFactor, _1, _2, _3, aimingTime = player._PlayerAvatar__aimingInfo
# aimingStartTime = aimingInfo[0]
# aimingFactor = aimingInfo[1]
# shotDispMultiplierFactor = aimingInfo[2]
# unShotDispersionFactorsTurretRotation = aimingInfo[3]
# chassisShotDispersionFactorsMovement = aimingInfo[4]
# chassisShotDispersionFactorsRotation = aimingInfo[5]
# aimingTime = aimingInfo[6]
aimingTimeAll = math.log(
aimingFactor / shotDispMultiplierFactor) * aimingTime
aimingFinishTime = aimingTimeAll + aimingStartTime
timeAIM = max(0.0, aimingFinishTime - BigWorld.time())
cameraHeight = camera.position.y - endPos.y
currentDistance = distance
as_event('ON_MARKER_POSITION')
if isDisplaySphere:
update_sphere(endPos)
except Exception as ex:
err(traceback.format_exc())
return base(self, shotPos, shotVec, dispersionAngles)
return endPos, direction, markerDiameter, idealMarkerDiameter, collData
def __calcEdgeLine(self, nodeIdA, nodeIdB):
if nodeIdA == nodeIdB:
pass
centerA, _, _, dimensionsA = self.__getNodeGeometry(nodeIdA)
centerB, _, _, dimensionsB = self.__getNodeGeometry(nodeIdB)
sectorA = sectorB = None
sectorIdsA = [ sector.sectorID for sector in self.__sectorComponent.getSectorGroupById(nodeIdA).sectors ]
for sectorOfB in self.__sectorComponent.getSectorGroupById(nodeIdB).sectors:
for neighbourOfBId in self.__sectorComponent.getNeighbouringSectorIdsByOwnSectorId(sectorOfB.sectorID):
if neighbourOfBId in sectorIdsA:
sectorA = self.__sectorComponent.getSectorById(neighbourOfBId)
sectorB = sectorOfB
break
if None in (sectorA, sectorB):
return (None, None)
else:
if getArena().arenaType.epicSectorGrid.mainDirection in (AAD.PLUS_Z, AAD.MINUS_Z):
isHorizontal = sectorA.playerGroup == sectorB.playerGroup
else:
isHorizontal = sectorA.IDInPlayerGroup == sectorB.IDInPlayerGroup
comparisonFunc = (lambda a, b: a.x <= b.x) if isHorizontal else (lambda a, b: a.z <= b.z)
shortWidth, shortHeight, longWidth, longHeight, shortCenter, longCenter = (dimensionsA.x,
dimensionsA.z,
dimensionsB.x,
dimensionsB.z,
centerA,
centerB) if comparisonFunc(dimensionsA, dimensionsB) else (dimensionsB.x,
dimensionsB.z,
dimensionsA.x,
dimensionsA.z,
centerB,
centerA)
if isHorizontal:
z = longCenter.z + copysign(longHeight * 0.5, shortCenter.z - longCenter.z)
return (Vector3(shortCenter.x - shortWidth * 0.5, 0, z), Vector3(shortCenter.x + shortWidth * 0.5, 0, z))
x = longCenter.x + copysign(longWidth * 0.5, shortCenter.x - longCenter.x)
return (Vector3(x, 0, shortCenter.z - shortHeight * 0.5), Vector3(x, 0, shortCenter.z + shortHeight * 0.5))
def __spreadAnchorsApart(self, visibleAnchors):
for slotIds in visibleAnchors.itervalues():
anchorsCount = len(slotIds)
if anchorsCount > 1:
radius = _MIN_PROJECTION_DECAL_ANCHORS_DIST * 0.5 / math.sin(math.pi / anchorsCount)
position = sum((self.__processedAnchors[slotId].position for slotId in slotIds), Vector3()) / anchorsCount
direction = sum((self.__processedAnchors[slotId].direction for slotId in slotIds), Vector3()) / anchorsCount
transformMatrix = Math.Matrix()
transformMatrix.lookAt(position, direction, (0, 1, 0))
transformMatrix.invert()
shift = Vector3(0, radius, 0)
angle = 2 * math.pi / anchorsCount
rotor = Math.Matrix()
rotor.setRotateZ(angle)
for slotId in sorted(slotIds, key=getProjectionSlotFormfactor):
anchor = self.__processedAnchors[slotId]
newPosition = transformMatrix.applyPoint(shift)
anchor.setShift(newPosition - anchor.position)
self.setAnchorShift(slotId, anchor.shift)
shift = rotor.applyPoint(shift)
slotId = slotIds.pop()
self.setAnchorShift(slotId, Vector3())
def __updateMatrix(self):
bb = BigWorld.player().arena.arenaType.boundingBox
pos2D = _clampPoint2DInBox2D(
bb[0], bb[1],
Math.Vector2(self.__planePosition.x, self.__planePosition.z))
self.__planePosition.x = pos2D[0]
self.__planePosition.z = pos2D[1]
collPoint = BigWorld.wg_collideSegment(
BigWorld.player().spaceID,
self.__planePosition + Math.Vector3(0, 1000.0, 0),
self.__planePosition + Math.Vector3(0, -250.0, 0), 3)
heightFromPlane = 0.0 if collPoint is None else collPoint[0][1]
self._matrix.translation = self.__planePosition + Vector3(
0, heightFromPlane + self.__height, 0)
class StrategicAimingSystem(IAimingSystem):
_LOOK_DIR = Vector3(0, -math.cos(0.001), math.sin(0.001))
height = property(lambda self: self.__height)
heightFromPlane = property(lambda self: self.__heightFromPlane)
def __init__(self, height, yaw):
self._matrix = mathUtils.createRotationMatrix((yaw, 0, 0))
self.__planePosition = Vector3(0, 0, 0)
self.__height = height
self.__heightFromPlane = 0.0
def destroy(self):
pass
def enable(self, targetPos):
self.updateTargetPos(targetPos)
def disable(self):
pass
def getDesiredShotPoint(self, terrainOnlyCheck=False):
return AimingSystems.getDesiredShotPoint(self._matrix.translation,
Vector3(0, -1, 0), True, True,
terrainOnlyCheck)
def handleMovement(self, dx, dy):
shift = self._matrix.applyVector(Vector3(dx, 0, dy))
self.__planePosition += Vector3(shift.x, 0, shift.z)
self.__updateMatrix()
def updateTargetPos(self, targetPos):
self.__planePosition.x = targetPos.x
self.__planePosition.z = targetPos.z
self.__updateMatrix()
def __updateMatrix(self):
bb = BigWorld.player().arena.arenaType.boundingBox
pos2D = _clampPoint2DInBox2D(
bb[0], bb[1],
Math.Vector2(self.__planePosition.x, self.__planePosition.z))
self.__planePosition.x = pos2D[0]
self.__planePosition.z = pos2D[1]
collPoint = BigWorld.wg_collideSegment(
BigWorld.player().spaceID,
self.__planePosition + Math.Vector3(0, 1000.0, 0),
self.__planePosition + Math.Vector3(0, -250.0, 0), 3)
self.__heightFromPlane = 0.0 if collPoint is None else collPoint[0][1]
self._matrix.translation = self.__planePosition + Vector3(
0, self.__heightFromPlane + self.__height, 0)
return
def disable(self):
if not self.__isEnabled:
return
else:
self.__isEnabled = False
self.__cam.disable()
self.__activeSelector.destroy()
self.__activeSelector = _DefaultStrikeSelector(Vector3(0, 0, 0), None)
self.stopCallback(self.__tick)
self.setGUIVisible(False)
self.__cam.writeUserPreferences()
if BigWorld.player().gunRotator is not None:
BigWorld.player().gunRotator.ignoreAimingMode = False
return
def __getLandAt(self, position):
if self.__ignoreTerrain:
return Vector3(position.x, 0, position.z)
else:
spaceID = BigWorld.player().spaceID
if spaceID is None:
return
upPoint = Math.Vector3(position)
upPoint.y += 1000
downPoint = Math.Vector3(position)
downPoint.y = -1000
collideRes = BigWorld.wg_collideSegment(spaceID, upPoint,
downPoint, 16, 8)
return None if collideRes is None else collideRes.closestPoint
def __calcCurOscillatorAcceleration(self, deltaTime):
vehicle = BigWorld.player().vehicle
if vehicle is None:
return Vector3(0, 0, 0)
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 __cameraUpdate(self):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
else:
aimOffset = self.__calcAimOffset()
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
self.__aimOffset = aimOffset
shotDescr = BigWorld.player().getVehicleDescriptor().shot
BigWorld.wg_trajectory_drawer().setParams(shotDescr.maxDistance, Math.Vector3(0, -shotDescr.gravity, 0), aimOffset)
curTime = BigWorld.time()
deltaTime = curTime - self.__prevTime
self.__prevTime = curTime
self.__aimingSystem.update(deltaTime)
if replayCtrl.isPlaying:
if self.__needReset != 0:
if self.__needReset > 1:
from helpers import isPlayerAvatar
player = BigWorld.player()
if isPlayerAvatar():
if player.inputHandler.ctrl is not None:
player.inputHandler.ctrl.resetGunMarkers()
self.__needReset = 0
else:
self.__needReset += 1
if replayCtrl.isControllingCamera:
self.__aimingSystem.updateTargetPos(replayCtrl.getGunRotatorTargetPoint())
else:
self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
if self.__dxdydz.x != 0 or self.__dxdydz.y != 0 or self.__dxdydz.z != 0:
self.__needReset = 2
else:
self.__aimingSystem.handleMovement(self.__dxdydz.x * self.__curSense, -self.__dxdydz.y * self.__curSense)
distRange = self.__getDistRange()
self.__calcSmoothingPivotDelta(deltaTime)
self.__camDist -= self.__dxdydz.z * float(self.__curSense)
self.__camDist = self.__aimingSystem.overrideCamDist(self.__camDist)
distRange = self.__getDistRange()
maxPivotHeight = distRange[1] - distRange[0]
self.__camDist = math_utils.clamp(0, maxPivotHeight, self.__camDist)
self._cfg['camDist'] = self.__camDist
camDistWithSmoothing = self.__camDist + self.__smoothingPivotDelta - self.__aimingSystem.heightFromPlane
self.__cam.pivotPosition = Math.Vector3(0.0, camDistWithSmoothing, 0.0)
if self.__dxdydz.z != 0 and self.__onChangeControlMode is not None and math_utils.almostZero(self.__camDist - maxPivotHeight):
self.__onChangeControlMode()
self.__updateOscillator(deltaTime)
if not self.__autoUpdatePosition:
self.__dxdydz = Vector3(0, 0, 0)
return 0.0
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 updateBomberTrajectory(self, equipmentID, team, curTime, curPos,
curDir, nextTime, nextPos, nextDir,
isDroppingPoint):
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('===== updateBomberTrajectory =====')
LOG_DEBUG(equipmentID, team)
LOG_DEBUG(curPos, curDir, curTime)
LOG_DEBUG(nextPos, nextDir, nextTime)
LOG_DEBUG(isDroppingPoint)
moveDir = nextPos - curPos
moveDir.normalise()
nextDir3d = Vector3(nextDir.x, moveDir.y, nextDir.y)
nextDir3d.normalise()
startP = BombersWing.CurveControlPoint(curPos,
Vector3(curDir.x, 0, curDir.y),
curTime)
nextP = BombersWing.CurveControlPoint(nextPos, nextDir3d, nextTime)
points = (startP, nextP)
wingID = (team, equipmentID)
wing = self.__wings.get(wingID)
if wing is None or wing.withdrawn:
if wing is not None:
wing.destroy()
self.__wings[wingID] = BombersWing.BombersWing(equipmentID, points)
if _ENABLE_DEBUG_DRAW:
self.debugPoints.append(curPos)
self.debugDirs.append(curDir)
else:
wing.addControlPoint(points, isDroppingPoint)
if _ENABLE_DEBUG_DRAW:
self.debugPoints.append(nextPos)
self.debugDirs.append(nextDir)
self.debugPoints.append(nextPos +
Vector3(nextDir.x, 0, nextDir.y) * 10)
self.debugPoints.append(nextPos)
self.debugPolyLine.set(self.debugPoints)
return
def __init__(self, mass, stiffness, drag, constraints):
IOscillator.__init__(self)
self.mass = mass
self.stiffness = Vector3(stiffness)
self.drag = Vector3(drag)
self.constraints = Vector3(constraints)
self.deviation = Vector3(0, 0, 0)
self.velocity = Vector3(0, 0, 0)
self.externalForce = Vector3(0, 0, 0)
def __init__(self, mass, stiffness, drag, restEpsilon = 0.001):
IOscillator.__init__(self)
self.mass = mass
self.stiffness = Vector3(stiffness)
self.drag = Vector3(drag)
self.deviation = Vector3(0, 0, 0)
self.velocity = Vector3(0, 0, 0)
self.externalForce = Vector3(0, 0, 0)
self.__time = 0.0
self.__startVelocity = Vector3(0, 0, 0)
self.restEpsilon = restEpsilon
sqr = self.drag / (2 * self.mass)
self.__omega = Vector3(math.sqrt(self.stiffness.x / self.mass - sqr.x * sqr.x), math.sqrt(self.stiffness.y / self.mass - sqr.y * sqr.y), math.sqrt(self.stiffness.z / self.mass - sqr.z * sqr.z))
