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 __init__(self):
self.__flagModel = None
self.__flagFashion = None
self.__flagScaleMatrix = Matrix()
self.__flagStaffModel = None
self.__flagStaffFashion = None
return
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 __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 __addEntryLit(self, id, matrix, visible = True):
battleCtx = g_sessionProvider.getCtx()
if battleCtx.isObserver(id):
return
if matrix is None:
return
mp = Math.WGReplayAwaredSmoothTranslationOnlyMP()
mp.source = matrix
scaledMatrix = None
if self.__markerScale is not None:
scaleMatrix = Matrix()
scaleMatrix.setScale(Vector3(self.__markerScale, self.__markerScale, self.__markerScale))
scaledMatrix = mathUtils.MatrixProviders.product(scaleMatrix, mp)
if scaledMatrix is None:
handle = self.__ownUI.addEntry(mp, self.zIndexManager.getVehicleIndex(id))
else:
handle = self.__ownUI.addEntry(scaledMatrix, self.zIndexManager.getVehicleIndex(id))
entry = {'matrix': mp,
'handle': handle}
arena = BigWorld.player().arena
entryVehicle = arena.vehicles[id]
entityName = battleCtx.getPlayerEntityName(id, entryVehicle.get('team'))
markerType = entityName.base
entryName = entityName.name()
self.__entrieLits[id] = entry
vName = entryVehicle['vehicleType'].type.shortUserString
self.__ownUI.entryInvoke(entry['handle'], ('init', [markerType,
entryName,
'lastLit',
'',
vName]))
if not visible:
self.__ownUI.entryInvoke(entry['handle'], ('setVisible', [visible]))
if self.__markerScale is None:
self.__parentUI.call('minimap.entryInited', [])
def __addDeadEntry(self, entry, id):
"""
adding death animation to minimap (WOTD-5884)
"""
if id in BigWorld.entities.keys():
m = self.__getEntryMatrixByLocation(id, entry['location'])
scaledMatrix = None
if self.__markerScale is not None:
scaleMatrix = Matrix()
scaleMatrix.setScale(Vector3(self.__markerScale, self.__markerScale, self.__markerScale))
scaledMatrix = mathUtils.MatrixProviders.product(scaleMatrix, m)
if scaledMatrix is None:
entry['handle'] = self.__ownUI.addEntry(m, self.zIndexManager.getDeadVehicleIndex(id))
else:
entry['handle'] = self.__ownUI.addEntry(scaledMatrix, self.zIndexManager.getVehicleIndex(id))
self.__entries[id] = entry
if not GUI_SETTINGS.permanentMinimapDeath:
self.__deadCallbacks[id] = BigWorld.callback(GUI_SETTINGS.minimapDeathDuration / 1000, partial(self.__delEntry, id))
self.__callEntryFlash(id, 'setDead', [GUI_SETTINGS.permanentMinimapDeath])
self.__callEntryFlash(id, 'init', [entry['markerType'],
entry['entryName'],
entry['vClass'],
''])
if self.__markerScale is None:
self.__parentUI.call('minimap.entryInited', [])
def scaleMarker(self, handle, originalMatrix, scale):
if handle is not None and originalMatrix is not None:
scaleMatrix = Matrix()
scaleMatrix.setScale(Vector3(scale, scale, scale))
mp = mathUtils.MatrixProviders.product(scaleMatrix, originalMatrix)
self.__ownUI.entrySetMatrix(handle, mp)
return
def __addEntryMarker(self, marker, matrix):
if matrix is None:
return
else:
mp = Math.WGReplayAwaredSmoothTranslationOnlyMP()
mp.source = matrix
scaledMatrix = None
if self.__markerScale is not None:
scaleMatrix = Matrix()
scaleMatrix.setScale(Vector3(self.__markerScale, self.__markerScale, self.__markerScale))
scaledMatrix = mathUtils.MatrixProviders.product(scaleMatrix, mp)
zIndex = self.zIndexManager.getMarkerIndex(marker)
if scaledMatrix is None:
handle = self.__ownUI.addEntry(mp, zIndex)
else:
handle = self.__ownUI.addEntry(scaledMatrix, zIndex)
entry = {'matrix': mp,
'handle': handle}
self.__entrieMarkers[marker] = entry
self.__ownUI.entryInvoke(entry['handle'], ('init', ['fortConsumables',
marker,
'',
'',
'empty']))
if self.__markerScale is None:
self.__parentUI.call('minimap.entryInited', [])
return handle
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 __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))
return
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 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 __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 __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):
worldCrosshair = Matrix(self.__crosshairMatrix)
aimingSystemMatrix = self.__aimingSystem.matrix
if aimLocalTransform is not None:
worldCrosshair.postMultiply(aimLocalTransform)
worldCrosshair.postMultiply(aimingSystemMatrix)
aimOffset = cameras.projectPoint(worldCrosshair.translation)
return Vector2(mathUtils.clamp(-0.95, 0.95, aimOffset.x), mathUtils.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)
class FlagModel(object):
model = property(lambda self: self.__flagStaffModel)
def __init__(self):
self.__flagModel = None
self.__flagAnimator = None
self.__flagFashion = None
self.__flagScaleMatrix = Matrix()
self.__flagStaffModel = None
self.__flagStaffFashion = None
return
def setupFlag(self, position, flagSettings, color):
self.__setupFlagStaff(flagSettings, position)
self.__setupFlagModel(flagSettings, color)
def changeFlagColor(self, color):
if self.__flagFashion:
self.__flagFashion.setColor(color)
def startFlagAnimation(self):
if self.__flagModel is not None:
try:
clipResource = self.__flagModel.deprecatedGetAnimationClipResource(self.__flagSettings.flagAnim)
if clipResource:
loader = AnimationSequence.Loader(clipResource, BigWorld.player().spaceID)
self.__flagAnimator = loader.loadSync()
self.__flagAnimator.bindTo(AnimationSequence.ModelWrapperContainer(self.__flagModel))
self.__flagAnimator.start()
except Exception:
LOG_WARNING('Unable to start "%s" animation action for model' % self.__flagSettings.flagAnim)
return
def __setupFlagStaff(self, flagSettings, position):
self.__flagStaffModel = flagSettings.flagStaffModel
self.__flagStaffModel.position = position
self.__flagStaffFashion = BigWorld.WGAlphaFadeFashion()
self.__flagStaffModel.fashion = self.__flagStaffFashion
def __setupFlagModel(self, flagSettings, color):
self.__flagSettings = flagSettings
self.__flagScaleMatrix = Matrix()
self.__flagScaleMatrix.setScale(flagSettings.flagScale)
flagNode = self.__flagStaffModel.node(flagSettings.flagStaffFlagHP, self.__flagScaleMatrix)
if self.__flagModel is not None:
flagNode.detach(self.__flagModel)
self.__flagModel = None
self.__flagModel = flagSettings.flagModel
self.__flagFashion = BigWorld.WGFlagAlphaFadeFashion()
self.__flagFashion.setColor(color)
self.__flagFashion.setFlagBackgroundTexture(flagSettings.flagBackgroundTex)
self.__flagFashion.setEmblemTexture(flagSettings.flagEmblemTex, flagSettings.flagEmblemTexCoords)
self.__flagModel.fashion = self.__flagFashion
if self.__flagModel is not None:
flagNode.attach(self.__flagModel)
self.__flagFashion.overridePosition(self.__flagStaffModel.matrix)
return
class FlagModel(object):
model = property(lambda self: self.__flagStaffModel)
def __init__(self):
self.__flagModel = None
self.__flagFashion = None
self.__flagScaleMatrix = Matrix()
self.__flagStaffModel = None
self.__flagStaffFashion = None
return
def setupFlag(self, position, flagSettings, color):
self.__setupFlagStaff(flagSettings, position)
self.__setupFlagModel(flagSettings, color)
def changeFlagColor(self, color):
if self.__flagFashion:
self.__flagFashion.setColor(color)
def startFlagAnimation(self):
if self.__flagModel is not None:
try:
animAction = self.__flagModel.action(
self.__flagSettings.flagAnim)
animAction()
except Exception:
LOG_WARNING('Unable to start "%s" animation action for model' %
self.__flagSettings.flagAnim)
return
def __setupFlagStaff(self, flagSettings, position):
self.__flagStaffModel = flagSettings.flagStaffModel
self.__flagStaffModel.position = position
self.__flagStaffFashion = BigWorld.WGAlphaFadeFashion()
self.__flagStaffModel.fashion = self.__flagStaffFashion
def __setupFlagModel(self, flagSettings, color):
self.__flagSettings = flagSettings
self.__flagScaleMatrix = Matrix()
self.__flagScaleMatrix.setScale(flagSettings.flagScale)
flagNode = self.__flagStaffModel.node(flagSettings.flagStaffFlagHP,
self.__flagScaleMatrix)
if self.__flagModel is not None:
flagNode.detach(self.__flagModel)
self.__flagModel = None
self.__flagModel = flagSettings.flagModel
self.__flagFashion = BigWorld.WGFlagAlphaFadeFashion()
self.__flagFashion.setColor(color)
self.__flagFashion.setFlagBackgroundTexture(
flagSettings.flagBackgroundTex)
self.__flagFashion.setEmblemTexture(flagSettings.flagEmblemTex,
flagSettings.flagEmblemTexCoords)
self.__flagModel.fashion = self.__flagFashion
if self.__flagModel is not None:
flagNode.attach(self.__flagModel)
self.__flagFashion.overridePosition(self.__flagStaffModel.matrix)
return
class ArtyAimingSystem(StrategicAimingSystem):
def __init__(self):
super(ArtyAimingSystem, self).__init__(0.0, 0.0)
self.__direction = Vector3(0.0, 0.0, 0.0)
self.__aimMatrix = Matrix()
@property
def aimMatrix(self):
return self.__aimMatrix
@property
def aimPoint(self):
return self.__aimMatrix.translation
@aimPoint.setter
def aimPoint(self, point):
self.__aimMatrix.setTranslate(point)
@property
def hitPoint(self):
return self._matrix.translation
@property
def direction(self):
return self.__direction
def getDesiredShotPoint(self, terrainOnlyCheck=False):
return self.__aimMatrix.translation
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 = mathUtils.createRTMatrix(
(self.__direction.yaw, -self.__direction.pitch, 0.0),
hitPoint[1])
self.__aimMatrix.setTranslate(aimPoint)
return
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 _setMarkerPosition(self, markerID, position):
"""Sets position of marker.
:param markerID: integer containing unique ID of marker.
:param position: Math.Vector3 containing new position.
:return:
"""
matrix = Matrix()
matrix.setTranslate(position)
self._parentObj.setMarkerMatrix(markerID, matrix)
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 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 _createMarkerWithPosition(self, symbol, position, active=True):
"""Creates 2D marker that has static position on world.
:param symbol: string containing name of symbol to create desired UI component in the Flash.
:param position: Math.Vector3 containing world position.
:param active: True if marker is visible, otherwise - False.
:return: integer containing unique ID of marker.
"""
matrixProvider = Matrix()
matrixProvider.translation = position
return self._parentObj.createMarker(symbol, matrixProvider, active)
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 prerequisites(self):
stepRepairPointComponent = BigWorld.player().arena.componentSystem.stepRepairPointComponent
if stepRepairPointComponent is not None:
stepRepairPointComponent.addStepRepairPoint(self)
rv = [_g_stepRepairPointSettings.flagModel, _g_stepRepairPointSettings.radiusModel]
mProv = Matrix()
mProv.translation = self.position
self.__stepRepairPointSoundObject = SoundGroups.g_instance.WWgetSoundObject('stepRepairPoint_' + str(self), mProv)
self.__stepRepairPointSoundObject.play(_g_stepRepairPointSettings.attachedSoundEventName)
return rv
def bind(self, vehicle, bindWorldPos = None):
self.__vehicle = vehicle
if vehicle is None:
self.matrix = mathUtils.createIdentityMatrix()
self.__lookAtProvider = None
return
toLocalMat = Matrix(vehicle.matrix)
toLocalMat.invert()
self.__boundLocalPos = None if bindWorldPos is None else toLocalMat.applyPoint(bindWorldPos)
self.selectPlacement(_VehicleBounder.SELECT_CHASSIS)
def destroyFireball(owner, fireball, fx, explosionFXName, targetHitCallback, prereqs):
m = Matrix(fireball.motors[0].target)
fx.detach()
owner.delModel(fireball)
explosion = BigWorld.Model('')
owner.addModel(explosion)
explosion.position = m.applyToOrigin()
fireballfx = FX.bufferedOneShotEffect(explosionFXName, explosion, explosion, lambda : owner.delModel(explosion), 10.0, prereqs)
if targetHitCallback != None:
targetHitCallback(owner, m)
return
def destroyFireball(owner, fireball, fx, explosionFXName, targetHitCallback, prereqs):
m = Matrix(fireball.motors[0].target)
fx.detach()
owner.delModel(fireball)
explosion = BigWorld.Model('')
owner.addModel(explosion)
explosion.position = m.applyToOrigin()
fireballfx = FX.bufferedOneShotEffect(explosionFXName, explosion, explosion, lambda : owner.delModel(explosion), 10.0, prereqs)
if targetHitCallback != None:
targetHitCallback(owner, m)
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 bind(self, vehicle, bindWorldPos = None):
self.__vehicle = vehicle
if vehicle is None:
self.matrix = mathUtils.createIdentityMatrix()
self.__lookAtProvider = None
return
else:
toLocalMat = Matrix(vehicle.matrix)
toLocalMat.invert()
self.__boundLocalPos = None if bindWorldPos is None else toLocalMat.applyPoint(bindWorldPos)
self.selectPlacement(_VehicleBounder.SELECT_CHASSIS)
return
def __init__(self, zone):
self._zone = zone
self._matrix = None
self._markerId = None
areaMarkerCtrl = self.sessionProvider.shared.areaMarker
if areaMarkerCtrl:
self._matrix = Matrix()
marker = areaMarkerCtrl.createMarker(self._matrix,
MarkerItem.DEATHZONE)
self._markerId = areaMarkerCtrl.addMarker(marker)
areaMarkerCtrl.onTickUpdate += self._tickUpdate
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 __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 _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 __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 worldHitTest(self, start, stop, worldMatrix):
worldToLocal = Matrix(worldMatrix)
worldToLocal.invert()
testRes = self.__bspModel.collideSegment(worldToLocal.applyPoint(start), worldToLocal.applyPoint(stop))
if testRes is None:
return
res = []
for dist, normal, hitAngleCos, matKind in testRes:
res.append((dist,
worldMatrix.applyVector(normal),
hitAngleCos,
matKind))
return res
def assembleCompoundModel(models, position, vehicleDesc):
tank = BigWorld.createCompoundTank()
chassis = BigWorld.ModelLite(models[0])
hull = BigWorld.ModelLite(models[1])
turret = BigWorld.ModelLite(models[2])
gun = BigWorld.ModelLite(models[3])
matrix = Matrix()
matrix.translation = position
tank.attachPart(0, chassis, '', matrix)
tank.attachPart(1, hull, 'V')
tank.attachPart(2, turret, 'HP_turretJoint')
tank.attachPart(3, gun, 'HP_gunJoint')
BigWorld.addModel(tank)
return tank
def assembleCompoundModel(models, position, vehicleDesc):
tank = BigWorld.createCompoundTank()
chassis = BigWorld.ModelLite(models[0])
hull = BigWorld.ModelLite(models[1])
turret = BigWorld.ModelLite(models[2])
gun = BigWorld.ModelLite(models[3])
matrix = Matrix()
matrix.translation = position
tank.attachPart(0, chassis, '', matrix)
tank.attachPart(1, hull, 'V')
tank.attachPart(2, turret, 'HP_turretJoint')
tank.attachPart(3, gun, 'HP_gunJoint')
BigWorld.addModel(tank)
return tank
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 __drawDebugOutput(self, matrixProvider):
self.__resetDebugOutput()
if matrixProvider is None:
return
else:
matrixProvider = Matrix(matrixProvider)
pos = matrixProvider.translation
endPos = matrixProvider.translation
endPos.y += 70.0
self.__debugLine = Flock.DebugLine(pos, endPos)
self.__debugLine.thickness = 1.0
matrixProvider.translation = pos
self.__debugGizmo.setMatrix(matrixProvider)
self.__callbackDelayer.delayCallback(4.0, self.__resetDebugOutput)
return
def prerequisites(self):
stepRepairPointComponent = BigWorld.player().arena.componentSystem.stepRepairPointComponent
if stepRepairPointComponent is not None:
stepRepairPointComponent.addStepRepairPoint(self)
assembler = BigWorld.CompoundAssembler(_g_stepRepairPointSettings.flagModel, self.spaceID)
assembler.addRootPart(_g_stepRepairPointSettings.flagModel, 'root')
rv = [assembler, _g_stepRepairPointSettings.radiusModel]
if _g_stepRepairPointSettings.flagAnim is not None:
loader = AnimationSequence.Loader(_g_stepRepairPointSettings.flagAnim, self.spaceID)
rv.append(loader)
mProv = Matrix()
mProv.translation = self.position
self.__stepRepairPointSoundObject = SoundGroups.g_instance.WWgetSoundObject('stepRepairPoint_' + str(self), mProv)
self.__stepRepairPointSoundObject.play(_g_stepRepairPointSettings.attachedSoundEventName)
return rv
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 __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.playSoundModel(self.__model, self.soundName)
except:
LOG_CURRENT_EXCEPTION()
self.__model = None
return
self.__prevTime = BigWorld.time()
self.__update()
return
def collideSegment(self, startPoint, endPoint, skipGun = False):
res = None
filterMethod = getattr(self.filter, 'segmentMayHitEntity', lambda : True)
if not filterMethod(startPoint, endPoint, 0):
return res
modelsToCheck = (self.model,) if skipGun else (self.model, self.__gunModel)
for model, desc in zip(modelsToCheck, self.__componentsDesc):
toModel = Matrix(model.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 __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 findTargets(self, actor, source, target):
self.calculatedTargets = []
origin = source.position + Vector3(0, 0.5, 0)
yaw = source.yaw + math.pi / 2.0
basis = Vector3(math.sin(yaw), 0, math.cos(yaw))
left = []
right = []
leftOver = self.maxNodes
victims = []
if hasattr(self, 'victims'):
victims = self.victims
elif self.findTeam == 1:
team = BigWorld.player().team()
for i in team.members.keys():
entity = BigWorld.entity(i)
if entity:
if (entity.position - origin).length < self.maxRange:
victims.append(entity)
entity = BigWorld.player()
if entity:
if (entity.position - origin).length < self.maxRange:
victims.append(entity)
for e in victims:
if e.inWorld:
dpos = e.position - origin
dpos.normalise()
dotp = basis.dot(dpos)
leftOver -= 2
try:
self.calculatedTargets.append(e.model.node('biped Spine'))
except:
self.calculatedTargets.append(e.model.node('Scene Root'))
while leftOver > 0:
m = Matrix()
if leftOver % 2 == 0:
m.setTranslate(self.randomStrike(source, basis, origin, 1))
self.calculatedTargets.append(m)
else:
m.setTranslate(self.randomStrike(source, basis, origin, 0))
self.calculatedTargets.append(m)
leftOver -= 1
def checkTurretDetachment(self, worldPos):
if self.__vehicle is None:
return
if self.__vehicle.isTurretDetached and not self.__placement == _VehicleBounder.SELECT_DETACHED_TURRET:
turretFound = None
for turret in DetachedTurret.allTurrets:
if turret.vehicleID == self.__vehicle.id and turret.model.visible:
turretFound = turret
break
if turretFound is None:
return
turretToGoalShift = worldPos - turretFound.position
toTurretMat = Matrix(turretFound.matrix)
toTurretMat.invert()
turretToGoalShift = toTurretMat.applyVector(turretToGoalShift)
self.matrix = turretFound.matrix
self.__lookAtProvider = None
self.__placement = _VehicleBounder.SELECT_DETACHED_TURRET
return turretToGoalShift
def update(self, vehicle, deltaTime):
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
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 plasmaExplode(owner, targetModel, delTargetModel):
m = BigWorld.Model('objects/models/fx/03_pchangs/shockwave.model')
targetModel.root.attach(m)
m.Go()
BigWorld.callback(1.0, partial(targetModel.root.detach, m))
m = targetModel.root
m2 = Matrix()
m2.setScale((5, 5, 5))
m2.postMultiply(m)
v1 = Vector4(1.0, 100000, 0, 0)
v2 = Vector4(0.0, 0, 0, 0)
v = Vector4Animation()
v.keyframes = [(0, v1), (0.5, v2)]
v.duration = 1
v.time = 0
try:
BigWorld.addWarp(0.5, m2, v)
except:
pass
shake(targetModel)
ps2 = Pixie.create('particles/plasma_blow.xml')
targetModel.root.attach(ps2)
ps2.system(0).actions[0].force(1)
BigWorld.callback(5.0, partial(targetModel.root.detach, ps2))
if delTargetModel:
BigWorld.callback(5.0, partial(owner.delModel, targetModel))
if BigWorld.player().flashBangCount == 0:
fba = Vector4Animation()
fba.keyframes = [(0, Vector4(0, 0, 0, 0)), (0.1, Vector4(0.1, 0.1, 0.2, 0.5)), (0.3, Vector4(0, 0, 0, 0))]
fba.duration = 0.3
try:
BigWorld.flashBangAnimation(fba)
except:
pass
BigWorld.callback(fba.duration, partial(BigWorld.flashBangAnimation, None))
return
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)
def decodeHitPoints(encodedPoints, vehicleDescr):
resultPoints = []
maxHitEffectCode = None
for encodedPoint in encodedPoints:
compName, hitEffectCode, startPoint, endPoint = DamageFromShotDecoder.decodeSegment(
encodedPoint, vehicleDescr
)
if startPoint == endPoint:
continue
maxHitEffectCode = max(hitEffectCode, maxHitEffectCode)
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)
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)
class CircularFlyer(BigWorld.UserDataObject):
def __init__(self):
BigWorld.UserDataObject.__init__(self)
self.__prevTime = BigWorld.time()
self.__angularVelocity = 2 * math.pi / self.rotationPeriod
if not self.rotateClockwise:
self.__angularVelocity *= -1
self.__currentAngle = 0.0
self.__updateCallbackId = None
self.__model = None
self.__modelMatrix = None
self.__sound = None
BigWorld.loadResourceListBG((self.modelName, self.pixieName), self.__onResourcesLoaded)
return
def __del__(self):
self.__clear()
def __clear(self):
if self.__updateCallbackId is not None:
BigWorld.cancelCallback(self.__updateCallbackId)
self.__updateCallbackId = None
if self.__sound is not None:
self.__sound.stop()
self.__sound = None
if self.__model is not None:
BigWorld.delModel(self.__model)
self.__model = None
return
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.playSoundModel(self.__model, self.soundName)
except:
LOG_CURRENT_EXCEPTION()
self.__model = None
return
self.__prevTime = BigWorld.time()
self.__update()
return
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 __worldYawPitchToTurret(self, worldYaw, worldPitch):
worldToTurret = Matrix(self.__vehicleMProv)
worldToTurret.invert()
worldToTurret.preMultiply(mathUtils.createRotationMatrix((worldYaw, worldPitch, 0.0)))
return (worldToTurret.yaw, worldToTurret.pitch)
def createIdentityMatrix():
result = Matrix()
result.setIdentity()
return result
def createRTMatrix(rotation, translation):
result = Matrix()
result.setRotateYPR(rotation)
result.translation = translation
return result
