def __getGunMarkerPosition(self, shotPos, shotVec, dispersionAngle):
shotDescr = self.__avatar.vehicleTypeDescriptor.shot
gravity = Math.Vector3(0.0, -shotDescr['gravity'], 0.0)
maxDist = shotDescr['maxDistance']
testStartPoint = shotPos
testEndPoint = shotPos + shotVec * 10000.0
testEntities = ProjectileMover.getCollidableEntities((self.__avatar.playerVehicleID,), testStartPoint, testEndPoint)
collideVehiclesAndStaticScene = ProjectileMover.collideVehiclesAndStaticScene
collideWithSpaceBB = self.__avatar.arena.collideWithSpaceBB
prevPos = shotPos
prevVelocity = shotVec
dt = 0.0
maxDistCheckFlag = False
while True:
dt += SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(prevPos, prevVelocity, gravity, SERVER_TICK_LENGTH, SHELL_TRAJECTORY_EPSILON_CLIENT)
prevCheckPoint = prevPos
bBreak = False
for curCheckPoint in checkPoints:
testRes = collideVehiclesAndStaticScene(prevCheckPoint, curCheckPoint, testEntities)
if testRes is not None:
collData = testRes[1]
if collData is not None and not collData.isVehicle():
collData = None
dir = testRes[0] - prevCheckPoint
endPos = testRes[0]
bBreak = True
break
pos = collideWithSpaceBB(prevCheckPoint, curCheckPoint)
if pos is not None:
collData = None
maxDistCheckFlag = True
dir = pos - prevCheckPoint
endPos = pos
bBreak = True
break
prevCheckPoint = curCheckPoint
if bBreak:
break
prevPos = shotPos + shotVec.scale(dt) + gravity.scale(dt * dt * 0.5)
prevVelocity = shotVec + gravity.scale(dt)
dir.normalise()
distance = (endPos - shotPos).length
markerDiameter = 2.0 * distance * dispersionAngle
if maxDistCheckFlag:
if endPos.distTo(shotPos) >= maxDist:
dir = endPos - shotPos
dir.normalise()
endPos = shotPos + dir.scale(maxDist)
distance = maxDist
markerDiameter = 2.0 * distance * dispersionAngle
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isClientReady:
markerDiameter, endPos, dir = replayCtrl.getGunMarkerParams(endPos, dir)
return (endPos,
dir,
markerDiameter,
collData)
def __getGunMarkerPosition(self, shotPos, shotVec, dispersionAngle):
shotDescr = self.__avatar.vehicleTypeDescriptor.shot
gravity = Math.Vector3(0.0, -shotDescr['gravity'], 0.0)
maxDist = shotDescr['maxDistance']
testStartPoint = shotPos
testEndPoint = shotPos + shotVec * 10000.0
testEntities = ProjectileMover.getCollidableEntities((self.__avatar.playerVehicleID,), testStartPoint, testEndPoint)
collideVehiclesAndStaticScene = ProjectileMover.collideVehiclesAndStaticScene
collideWithSpaceBB = self.__avatar.arena.collideWithSpaceBB
prevPos = shotPos
prevVelocity = shotVec
dt = 0.0
maxDistCheckFlag = False
while True:
dt += SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(prevPos, prevVelocity, gravity, SERVER_TICK_LENGTH, SHELL_TRAJECTORY_EPSILON_CLIENT)
prevCheckPoint = prevPos
bBreak = False
for curCheckPoint in checkPoints:
testRes = collideVehiclesAndStaticScene(prevCheckPoint, curCheckPoint, testEntities)
if testRes is not None:
collData = testRes[1]
if collData is not None and not collData.isVehicle():
collData = None
dir = testRes[0] - prevCheckPoint
endPos = testRes[0]
bBreak = True
break
pos = collideWithSpaceBB(prevCheckPoint, curCheckPoint)
if pos is not None:
collData = None
maxDistCheckFlag = True
dir = pos - prevCheckPoint
endPos = pos
bBreak = True
break
prevCheckPoint = curCheckPoint
if bBreak:
break
prevPos = shotPos + shotVec.scale(dt) + gravity.scale(dt * dt * 0.5)
prevVelocity = shotVec + gravity.scale(dt)
dir.normalise()
distance = (endPos - shotPos).length
markerDiameter = 2.0 * distance * dispersionAngle
if maxDistCheckFlag:
if endPos.distTo(shotPos) >= maxDist:
dir = endPos - shotPos
dir.normalise()
endPos = shotPos + dir.scale(maxDist)
distance = maxDist
markerDiameter = 2.0 * distance * dispersionAngle
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isClientReady:
markerDiameter, endPos, dir = replayCtrl.getGunMarkerParams(endPos, dir)
return (endPos,
dir,
markerDiameter,
collData)
def getShotTargetInfo(vehicle, preferredTargetPoint, gunRotator):
shotPos, shotVec, gravity = gunRotator.getShotParams(
preferredTargetPoint, True)
typeDescriptor = vehicle.typeDescriptor
shotDescriptor = typeDescriptor.shot
maxDist = shotDescriptor.maxDistance
collideWithArenaBB = BigWorld.player().arena.collideWithArenaBB
prevPos = shotPos
prevVelocity = shotVec
dt = 0.0
maxDistCheckFlag = False
while True:
dt += SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(
prevPos, prevVelocity, gravity, SERVER_TICK_LENGTH,
SHELL_TRAJECTORY_EPSILON_CLIENT)
prevCheckPoint = prevPos
bBreak = False
for curCheckPoint in checkPoints:
testRes = collideVehiclesAndStaticScene(prevCheckPoint,
curCheckPoint,
(vehicle.id, ))
if testRes is not None:
dir_ = testRes[0] - prevCheckPoint
endPos = testRes[0]
bBreak = True
break
collisionResult, intersection = collideWithArenaBB(
prevCheckPoint, curCheckPoint)
if collisionResult is CollisionResult.INTERSECTION:
maxDistCheckFlag = True
dir_ = intersection - prevCheckPoint
endPos = intersection
bBreak = True
break
elif collisionResult is CollisionResult.OUTSIDE:
maxDistCheckFlag = True
dir_ = prevVelocity
endPos = prevPos + prevVelocity
bBreak = True
break
prevCheckPoint = curCheckPoint
if bBreak:
break
prevPos = shotPos + shotVec.scale(dt) + gravity.scale(dt * dt * 0.5)
prevVelocity = shotVec + gravity.scale(dt)
dir_.normalise()
if maxDistCheckFlag:
if endPos.distTo(shotPos) >= maxDist:
dir_ = endPos - shotPos
dir_.normalise()
endPos = shotPos + dir_.scale(maxDist)
return (endPos, dir_)
def __calcTrajectory(self, r0, v0, gravity, isOwnShoot, tracerCameraPos):
ret = []
prevPos = r0
prevVelocity = v0
dt = 0.0
while True:
dt += constants.SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(prevPos, prevVelocity, gravity, constants.SERVER_TICK_LENGTH, constants.SHELL_TRAJECTORY_EPSILON_CLIENT)
prevCheckPoint = prevPos
for curCheckPoint in checkPoints:
hitPoint = BigWorld.player().arena.collideWithSpaceBB(prevCheckPoint, curCheckPoint)
if hitPoint is not None:
ret.append((hitPoint, (hitPoint[0] - r0[0]) / v0[0], None))
return ret
testRes = BigWorld.wg_collideSegment(BigWorld.player().spaceID, prevCheckPoint, curCheckPoint, 128)
if testRes is not None:
hitPoint = testRes[0]
distStatic = (hitPoint - prevCheckPoint).length
destructibleDesc = None
matKind = testRes[2]
if matKind in xrange(DESTRUCTIBLE_MATKIND.NORMAL_MIN, DESTRUCTIBLE_MATKIND.NORMAL_MAX + 1):
destructibleDesc = (testRes[5], testRes[4], matKind)
distWater = -1.0
if isOwnShoot:
rayDir = hitPoint - tracerCameraPos
rayDir.normalise()
rayEnd = hitPoint + rayDir * 1.5
testRes = BigWorld.wg_collideSegment(BigWorld.player().spaceID, tracerCameraPos, rayEnd, 128)
if testRes is not None:
distStatic = (testRes[0] - tracerCameraPos).length
distWater = BigWorld.wg_collideWater(tracerCameraPos, rayEnd)
else:
distWater = BigWorld.wg_collideWater(prevCheckPoint, curCheckPoint)
if distWater < 0 or distWater > distStatic:
ret.append((hitPoint, self.__getCollisionTime(r0, hitPoint, v0), destructibleDesc))
if destructibleDesc is None:
return ret
if distWater >= 0:
srcPoint = tracerCameraPos if isOwnShoot else prevCheckPoint
hitDirection = hitPoint - srcPoint
hitDirection.normalise()
hitPoint = srcPoint + hitDirection * distWater
ret.append((hitPoint, self.__getCollisionTime(r0, hitPoint, v0), None))
return ret
prevCheckPoint = curCheckPoint
prevPos = r0 + v0.scale(dt) + gravity.scale(dt * dt * 0.5)
prevVelocity = v0 + gravity.scale(dt)
return
def __getGunMarkerPosition(self, shotPos, shotVec, dispersionAngles):
shotDescr = self.__avatar.getVehicleDescriptor().shot
gravity = Math.Vector3(0.0, -shotDescr.gravity, 0.0)
maxDist = shotDescr.maxDistance
testVehicleID = self.getAttachedVehicleID()
collideVehiclesAndStaticScene = ProjectileMover.collideDynamicAndStatic
collideWithSpaceBB = self.__avatar.arena.collideWithSpaceBB
prevPos = shotPos
prevVelocity = shotVec
dt = 0.0
maxDistCheckFlag = False
while True:
dt += SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(
prevPos, prevVelocity, gravity, SERVER_TICK_LENGTH,
SHELL_TRAJECTORY_EPSILON_CLIENT)
prevCheckPoint = prevPos
bBreak = False
for curCheckPoint in checkPoints:
testRes = collideVehiclesAndStaticScene(
prevCheckPoint, curCheckPoint, (testVehicleID, ))
if testRes is not None:
collData = testRes[1]
if collData is not None and not collData.isVehicle():
collData = None
direction = testRes[0] - prevCheckPoint
endPos = testRes[0]
bBreak = True
break
collisionResult, intersection = collideWithSpaceBB(
prevCheckPoint, curCheckPoint)
if collisionResult is CollisionResult.INTERSECTION:
collData = None
maxDistCheckFlag = True
direction = intersection - prevCheckPoint
endPos = intersection
bBreak = True
break
elif collisionResult is CollisionResult.OUTSIDE:
collData = None
maxDistCheckFlag = True
direction = prevVelocity
endPos = prevPos + prevVelocity
bBreak = True
prevCheckPoint = curCheckPoint
if bBreak:
break
prevPos = shotPos + shotVec.scale(dt) + gravity.scale(
dt * dt * 0.5)
prevVelocity = shotVec + gravity.scale(dt)
direction.normalise()
distance = (endPos - shotPos).length
markerDiameter = 2.0 * distance * dispersionAngles[0]
idealMarkerDiameter = 2.0 * distance * dispersionAngles[1]
if maxDistCheckFlag:
if endPos.distTo(shotPos) >= maxDist:
direction = endPos - shotPos
direction.normalise()
endPos = shotPos + direction.scale(maxDist)
distance = maxDist
markerDiameter = 2.0 * distance * dispersionAngles[0]
idealMarkerDiameter = 2.0 * distance * dispersionAngles[1]
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isClientReady:
markerDiameter, endPos, direction = replayCtrl.getGunMarkerParams(
endPos, direction)
return (endPos, direction, markerDiameter, idealMarkerDiameter,
collData)
def __getGunMarkerPosition(self, shotPos, shotVec, dispersionAngle):
shotDescr = self.__avatar.vehicleTypeDescriptor.shot
gravity = Math.Vector3(0.0, -shotDescr['gravity'], 0.0)
maxDist = shotDescr['maxDistance']
vehicles = []
testStartPoint = shotPos
testEndPoint = shotPos + shotVec * 10000.0
for vehicleID in BigWorld.player().arena.vehicles.iterkeys():
if vehicleID == self.__avatar.playerVehicleID:
continue
vehicle = BigWorld.entity(vehicleID)
if vehicle is None or not vehicle.isStarted:
continue
if segmentMayHitVehicle(vehicle.typeDescriptor, testStartPoint,
testEndPoint, vehicle.position):
vehicles.append(vehicle)
prevPos = shotPos
prevVelocity = shotVec
dt = 0.0
maxDistCheckFlag = False
while True:
dt += SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(
prevPos, prevVelocity, gravity, SERVER_TICK_LENGTH,
SHELL_TRAJECTORY_EPSILON_CLIENT)
prevCheckPoint = prevPos
bBreak = False
for curCheckPoint in checkPoints:
testRes = collideVehiclesAndStaticScene(
prevCheckPoint, curCheckPoint, vehicles)
if testRes is not None:
collData = testRes[1]
dir = testRes[0] - prevCheckPoint
endPos = testRes[0]
bBreak = True
break
pos = self.__avatar.arena.collideWithSpaceBB(
prevCheckPoint, curCheckPoint)
if pos is not None:
collData = None
maxDistCheckFlag = True
dir = pos - prevCheckPoint
endPos = pos
bBreak = True
break
prevCheckPoint = curCheckPoint
if bBreak:
break
prevPos = shotPos + shotVec.scale(dt) + gravity.scale(
dt * dt * 0.5)
prevVelocity = shotVec + gravity.scale(dt)
dir.normalise()
distance = (endPos - shotPos).length
markerDiameter = 2.0 * distance * dispersionAngle
if maxDistCheckFlag:
if endPos.distTo(shotPos) >= maxDist:
dir = endPos - shotPos
dir.normalise()
endPos = shotPos + dir.scale(maxDist)
distance = maxDist
markerDiameter = 2.0 * distance * dispersionAngle
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isClientReady:
markerDiameter, endPos, dir = replayCtrl.getGunMarkerParams(
endPos, dir)
elif replayCtrl.isRecording:
replayCtrl.setGunMarkerParams(markerDiameter, endPos, dir)
return (endPos, dir, markerDiameter, collData)
def __calcTrajectory(self, r0, v0, gravity, maxDistance, isOwnShoot, tracerCameraPos):
ret = []
ownVehicle = BigWorld.entities.get(BigWorld.player().playerVehicleID)
prevPos = r0
prevVelocity = v0
dt = 0.0
destrID = []
while True:
dt += constants.SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(prevPos, prevVelocity, gravity, constants.SERVER_TICK_LENGTH, constants.SHELL_TRAJECTORY_EPSILON_CLIENT)
prevCheckPoint = prevPos
prevDist0 = r0.distTo(prevCheckPoint)
for curCheckPoint in checkPoints:
curDist0 = r0.distTo(curCheckPoint)
if curDist0 > maxDistance:
curCheckPoint = prevCheckPoint + (curCheckPoint - prevCheckPoint) * ((maxDistance - prevDist0) / (curDist0 - prevDist0))
ret.append((curCheckPoint, (curCheckPoint[0] - r0[0]) / v0[0], None))
return ret
hitPoint = BigWorld.player().arena.collideWithSpaceBB(prevCheckPoint, curCheckPoint)
if hitPoint is not None:
ret.append((hitPoint, (hitPoint[0] - r0[0]) / v0[0], None))
return ret
testRes = BigWorld.wg_collideSegment(BigWorld.player().spaceID, prevCheckPoint, curCheckPoint, 128, lambda matKind, collFlags, itemID, chunkID: (False if itemID in destrID else True))
if testRes is not None:
hitPoint = testRes[0]
distStatic = (hitPoint - prevCheckPoint).length
destructibleDesc = None
matKind = testRes[2]
if matKind in xrange(DESTRUCTIBLE_MATKIND.NORMAL_MIN, DESTRUCTIBLE_MATKIND.NORMAL_MAX + 1):
destructibleDesc = (testRes[5], testRes[4], matKind)
destrID.append(testRes[4])
distWater = -1.0
useTracerCameraPos = False
if isOwnShoot:
rayDir = hitPoint - tracerCameraPos
rayDir.normalise()
if ownVehicle is not None:
gunPos = ownVehicle.appearance.modelsDesc['gun']['model'].position
if tracerCameraPos.y > gunPos.y:
if (hitPoint - gunPos).length > 30.0:
useTracerCameraPos = True
if not useTracerCameraPos:
distWater = BigWorld.wg_collideWater(prevCheckPoint, curCheckPoint, False)
else:
rayEnd = hitPoint + rayDir * 1.5
testRes = BigWorld.wg_collideSegment(BigWorld.player().spaceID, tracerCameraPos, rayEnd, 128)
if testRes is not None:
distStatic = (testRes[0] - tracerCameraPos).length
distWater = BigWorld.wg_collideWater(tracerCameraPos, rayEnd, False)
else:
distWater = BigWorld.wg_collideWater(prevCheckPoint, curCheckPoint, False)
if distWater < 0 or distWater > distStatic:
ret.append((hitPoint, self.__getCollisionTime(r0, hitPoint, v0), destructibleDesc))
if destructibleDesc is None:
return ret
prevCheckPoint = hitPoint
continue
if distWater >= 0:
srcPoint = tracerCameraPos if useTracerCameraPos else prevCheckPoint
hitDirection = hitPoint - srcPoint
hitDirection.normalise()
hitPoint = srcPoint + hitDirection * distWater
ret.append((hitPoint, self.__getCollisionTime(r0, hitPoint, v0), None))
return ret
prevCheckPoint = curCheckPoint
prevDist0 = curDist0
prevPos = r0 + v0.scale(dt) + gravity.scale(dt * dt * 0.5)
prevVelocity = v0 + gravity.scale(dt)
return
def __calcTrajectory(self, r0, v0, gravity, isOwnShoot, tracerCameraPos):
ret = []
prevPos = r0
prevVelocity = v0
dt = 0.0
while True:
dt += constants.SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(
prevPos, prevVelocity, gravity, constants.SERVER_TICK_LENGTH,
constants.SHELL_TRAJECTORY_EPSILON_CLIENT)
prevCheckPoint = prevPos
for curCheckPoint in checkPoints:
hitPoint = BigWorld.player().arena.collideWithSpaceBB(
prevCheckPoint, curCheckPoint)
if hitPoint is not None:
ret.append((hitPoint, (hitPoint[0] - r0[0]) / v0[0], None))
return ret
testRes = BigWorld.wg_collideSegment(BigWorld.player().spaceID,
prevCheckPoint,
curCheckPoint, 128)
if testRes is not None:
hitPoint = testRes[0]
distStatic = (hitPoint - prevCheckPoint).length
destructibleDesc = None
matKind = testRes[2]
if matKind in xrange(DESTRUCTIBLE_MATKIND.NORMAL_MIN,
DESTRUCTIBLE_MATKIND.NORMAL_MAX + 1):
destructibleDesc = (testRes[5], testRes[4], matKind)
distWater = -1.0
if isOwnShoot:
rayDir = hitPoint - tracerCameraPos
rayDir.normalise()
rayEnd = hitPoint + rayDir * 1.5
testRes = BigWorld.wg_collideSegment(
BigWorld.player().spaceID, tracerCameraPos, rayEnd,
128)
if testRes is not None:
distStatic = (testRes[0] - tracerCameraPos).length
distWater = BigWorld.wg_collideWater(
tracerCameraPos, rayEnd)
else:
distWater = BigWorld.wg_collideWater(
prevCheckPoint, curCheckPoint)
if distWater < 0 or distWater > distStatic:
ret.append(
(hitPoint,
self.__getCollisionTime(r0, hitPoint,
v0), destructibleDesc))
if destructibleDesc is None:
return ret
if distWater >= 0:
srcPoint = tracerCameraPos if isOwnShoot else prevCheckPoint
hitDirection = hitPoint - srcPoint
hitDirection.normalise()
hitPoint = srcPoint + hitDirection * distWater
ret.append((hitPoint,
self.__getCollisionTime(r0, hitPoint,
v0), None))
return ret
prevCheckPoint = curCheckPoint
prevPos = r0 + v0.scale(dt) + gravity.scale(dt * dt * 0.5)
prevVelocity = v0 + gravity.scale(dt)
return
def __getGunMarkerPosition(self, shotPos, shotVec, dispersionAngle):
shotDescr = self.__avatar.vehicleTypeDescriptor.shot
gravity = Math.Vector3(0.0, -shotDescr["gravity"], 0.0)
maxDist = shotDescr["maxDistance"]
vehicles = []
testStartPoint = shotPos
testEndPoint = shotPos + shotVec * 10000.0
for vehicleID in BigWorld.player().arena.vehicles.iterkeys():
if vehicleID == self.__avatar.playerVehicleID:
continue
vehicle = BigWorld.entity(vehicleID)
if vehicle is None or not vehicle.isStarted:
continue
if segmentMayHitVehicle(vehicle.typeDescriptor, testStartPoint, testEndPoint, vehicle.position):
vehicles.append(vehicle)
prevPos = shotPos
prevVelocity = shotVec
dt = 0.0
maxDistCheckFlag = False
while True:
dt += SERVER_TICK_LENGTH
checkPoints = computeProjectileTrajectory(
prevPos, prevVelocity, gravity, SERVER_TICK_LENGTH, SHELL_TRAJECTORY_EPSILON_CLIENT
)
prevCheckPoint = prevPos
bBreak = False
for curCheckPoint in checkPoints:
testRes = collideVehiclesAndStaticScene(prevCheckPoint, curCheckPoint, vehicles)
if testRes is not None:
collData = testRes[1]
dir = testRes[0] - prevCheckPoint
endPos = testRes[0]
bBreak = True
break
pos = self.__avatar.arena.collideWithSpaceBB(prevCheckPoint, curCheckPoint)
if pos is not None:
collData = None
maxDistCheckFlag = True
dir = pos - prevCheckPoint
endPos = pos
bBreak = True
break
prevCheckPoint = curCheckPoint
if bBreak:
break
prevPos = shotPos + shotVec.scale(dt) + gravity.scale(dt * dt * 0.5)
prevVelocity = shotVec + gravity.scale(dt)
dir.normalise()
distance = (endPos - shotPos).length
markerDiameter = 2.0 * distance * dispersionAngle
if maxDistCheckFlag:
if endPos.distTo(shotPos) >= maxDist:
dir = endPos - shotPos
dir.normalise()
endPos = shotPos + dir.scale(maxDist)
distance = maxDist
markerDiameter = 2.0 * distance * dispersionAngle
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isClientReady:
markerDiameter, endPos, dir = replayCtrl.getGunMarkerParams(endPos, dir)
elif replayCtrl.isRecording:
replayCtrl.setGunMarkerParams(markerDiameter, endPos, dir)
return (endPos, dir, markerDiameter, collData)
