def resetShellsSettings(self, currentShellCD, nextShellCD):
if self.shellInAmmo(currentShellCD):
curQuantity, _ = self.__ammo[currentShellCD]
if curQuantity <= 0:
currentShellCD = self.__getFirstAvailableShell()
elif currentShellCD is None:
currentShellCD = self.__getFirstAvailableShell()
else:
LOG_CODEPOINT_WARNING(
'Shell is not found in received list to set as current.',
currentShellCD)
if self.shellInAmmo(nextShellCD):
nextQuantity, _ = self.__ammo[nextShellCD]
if nextQuantity <= 0:
nextShellCD = None
elif nextShellCD is not None:
LOG_CODEPOINT_WARNING(
'Shell is not found in received list to set as next.',
nextShellCD)
if currentShellCD is not None:
self.changeSetting(currentShellCD)
self.changeSetting(currentShellCD)
else:
self.__currShellCD = None
self.onCurrentShellReset()
if nextShellCD is not None:
self.changeSetting(nextShellCD)
else:
self.__nextShellCD = None
self.processDelayer('setCurrentShellCD')
return
def decodeSegment(segment,
collisionComponent,
maxComponentIdx=TankPartIndexes.ALL[-1],
vehicleDesc=None):
if collisionComponent is None:
return (-1, int(segment & 255), None, None)
else:
compIdx = segment >> 8 & 255
if compIdx > maxComponentIdx:
LOG_CODEPOINT_WARNING(compIdx)
return (-1, int(segment & 255), None, None)
bbox = collisionComponent.getBoundingBox(
DamageFromShotDecoder.convertComponentIndex(
compIdx, vehicleDesc))
minimum = Math.Vector3(bbox[0])
delta = (bbox[1] - minimum).scale(1.0 / 255.0)
segStart = minimum + Math.Vector3(delta[0] *
(segment >> 16 & 255), delta[1] *
(segment >> 24 & 255), delta[2] *
(segment >> 32 & 255))
segEnd = minimum + Math.Vector3(delta[0] *
(segment >> 40 & 255), delta[1] *
(segment >> 48 & 255), delta[2] *
(segment >> 56 & 255))
offset = (segEnd - segStart) * 0.01
return (compIdx, int(segment & 255), segStart - offset,
segEnd + offset)
def __stopExtras(self):
extraTypes = self.typeDescriptor.extras
for index, data in self.extras.items():
extraTypes[index].stop(data)
if self.extras:
LOG_CODEPOINT_WARNING()
def __onSyncStreamComplete(self, syncID, isSuccess, data):
if isSuccess:
try:
data = zlib.decompress(data)
data = cPickle.loads(data)
except:
if data is None:
LOG_CODEPOINT_WARNING()
else:
LOG_CURRENT_EXCEPTION()
errors = self.__streamErrors.setdefault(syncID, 0) + 1
if errors >= self.__STREAM_ERRORS_LIMIT:
LOG_ERROR('Too many errors in data stream. Disconnecting.',
errors, syncID)
BigWorld.callback(0.001, BigWorld.disconnect)
return
self.__streamErrors[syncID] = errors
self.__sendSyncRequest(syncID,
partial(self.__onSyncResponse, syncID))
return
self.__onOwnerSyncComplete(syncID, data)
for callback in self.__syncRequests.pop(syncID, []):
try:
callback(AccountCommands.RES_STREAM, data)
except:
LOG_CURRENT_EXCEPTION()
return
def shootInSkyPoint(startPos, dir):
dirFromCam = dir
start = startPos
dirFromCam.normalise()
vehicle = BigWorld.player().vehicle
if vehicle is not None and vehicle.inWorld and vehicle.isStarted and not vehicle.isTurretDetached:
compoundModel = vehicle.appearance.compoundModel
shotPos = Math.Vector3(compoundModel.node(TankPartNames.GUN).position)
shotDesc = vehicle.typeDescriptor.shot
else:
type = BigWorld.player().arena.vehicles[
BigWorld.player().playerVehicleID]['vehicleType']
shotPos = BigWorld.player().getOwnVehiclePosition()
shotPos += type.hull['turretPositions'][0] + type.turret['gunPosition']
shotDesc = type.shot
dirAtCam = shotPos - start
dirAtCam.normalise()
cosAngle = dirAtCam.dot(dirFromCam)
a = shotDesc['maxDistance']
b = shotPos.distTo(start)
try:
dist = b * cosAngle + math.sqrt(b * b *
(cosAngle * cosAngle - 1) + a * a)
except:
dist = shotDesc['maxDistance']
LOG_CODEPOINT_WARNING()
if dist < 0.0:
dist = shotDesc['maxDistance']
finalPoint = start + dirFromCam.scale(dist)
intersecPoint = BigWorld.player().arena.collideWithSpaceBB(
start, finalPoint)
if intersecPoint is not None:
finalPoint = intersecPoint
return finalPoint
def decodeSegment(segment, vehicleDescr):
compIdx = segment >> 8 & 255
if compIdx == 0:
componentName = TankPartNames.CHASSIS
bbox = vehicleDescr.chassis['hitTester'].bbox
elif compIdx == 1:
componentName = TankPartNames.HULL
bbox = vehicleDescr.hull['hitTester'].bbox
elif compIdx == 2:
componentName = TankPartNames.TURRET
bbox = vehicleDescr.turret['hitTester'].bbox
elif compIdx == 3:
componentName = TankPartNames.GUN
bbox = vehicleDescr.gun['hitTester'].bbox
else:
LOG_CODEPOINT_WARNING(compIdx)
return ('', int(segment & 255), None, None)
min = Math.Vector3(bbox[0])
delta = (bbox[1] - min).scale(1.0 / 255.0)
segStart = min + Math.Vector3(delta[0] *
(segment >> 16 & 255), delta[1] *
(segment >> 24 & 255), delta[2] *
(segment >> 32 & 255))
segEnd = min + Math.Vector3(delta[0] *
(segment >> 40 & 255), delta[1] *
(segment >> 48 & 255), delta[2] *
(segment >> 56 & 255))
offset = (segEnd - segStart) * 0.01
return (componentName, int(segment & 255), segStart - offset,
segEnd + offset)
def setPlayerAssistResult(self, assistType, details):
if not self.__isPEEnabled:
return
else:
eventID = None
series = 1
if assistType == _SET.SPOTTED:
eventID = _EVENT_ID.PLAYER_SPOTTED_ENEMY
series = self.__getSeries(details)
elif assistType in (_SET.RADIO_HIT_ASSIST, _SET.RADIO_KILL_ASSIST,
_SET.TRACK_ASSIST):
series = self.__getSeries(details)
eventID = _EVENT_ID.PLAYER_ASSIST_TO_KILL_ENEMY
elif assistType == _SET.BASE_CAPTURE_POINTS:
eventID = _EVENT_ID.PLAYER_CAPTURED_BASE
elif assistType == _SET.BASE_CAPTURE_DROPPED:
eventID = _EVENT_ID.PLAYER_DROPPED_CAPTURE
elif assistType == _SET.TANKING:
eventID = _EVENT_ID.PLAYER_USED_ARMOR
series = findFirst(None, details, default=1)
else:
LOG_CODEPOINT_WARNING(assistType)
if eventID:
self.__pushPlayerEvent(eventID, series)
return
def __call__(self, command, args):
if self.__weakObj() is not None:
return getattr(self.__weakObj(), self.__funcName)(command, args)
else:
LOG_CODEPOINT_WARNING('weak object has been already destroyed.')
return
return
def applyLevelToAttrsDict(self, level, attrsDict, attrName):
if self.opType is None:
LOG_CODEPOINT_WARNING('Should not apply factors with no opType!')
return
else:
activeValue = self.getActiveValue(level)
AttrsOperation.updateDictWithAttribute(attrsDict, attrName,
self.opType, activeValue)
return
def setNextShellCD(self, intCD):
result = False
if intCD in self.__ammo:
if self.__nextShellCD != intCD:
self.__nextShellCD = intCD
self.onNextShellChanged(intCD)
result = True
else:
LOG_CODEPOINT_WARNING(
'Shell is not found in received list to set as next.', intCD)
return result
def setCurrentShellCD(self, intCD):
result = False
if intCD in self.__ammo:
if self.__currShellCD != intCD:
self.__currShellCD = intCD
self._reloadingState.startPredictedReloading()
self.__onCurrentShellChanged(intCD)
result = True
else:
LOG_CODEPOINT_WARNING(
'Shell is not found in received list to set as current.',
intCD)
return result
def __getPrestigeAwards(self, maxRewardTokens, size=AWARDS_SIZES.SMALL):
metaLevelComp = self.lobbyCtx.getServerSettings(
).epicMetaGame.metaLevel
if maxRewardTokens > metaLevelComp.get('maxRewardTokens', -1):
LOG_CODEPOINT_WARNING()
LOG_ERROR('This line of code should never be reached!')
self.fireEvent(
events.LoadViewEvent(
EPICBATTLES_ALIASES.EPIC_BATTLES_INFO_ALIAS),
EVENT_BUS_SCOPE.LOBBY)
return []
return getPrestigeLevelAwardsVOs(self.eventsCache.getAllQuests(),
maxRewardTokens, size)
def orderDestructibleDestroy(self,
chunkID,
dmgType,
destrData,
isNeedAnimation,
syncWithProjectile=False):
if self.forceNoAnimation:
isNeedAnimation = False
if self.__loadedChunkIDs.has_key(chunkID):
if isNeedAnimation and syncWithProjectile:
if dmgType == DestructiblesCache.DESTR_TYPE_FRAGILE:
itemIndex, _ = DestructiblesCache.decodeFragile(destrData)
matKind = 0
elif dmgType == DestructiblesCache.DESTR_TYPE_STRUCTURE:
itemIndex, matKind, _ = DestructiblesCache.decodeDestructibleModule(
destrData)
else:
LOG_CODEPOINT_WARNING()
return
self.__reduceExplosionCacheByTimeout()
for expl in reversed(self.__projectileExplosions):
time, explInfo, damagedDestrs = expl
for destr in damagedDestrs:
chunkID_, itemIndex_, matKind_ = destr
if chunkID == chunkID_ and itemIndex == itemIndex_ and (
dmgType
== DestructiblesCache.DESTR_TYPE_FRAGILE
or matKind == matKind_):
self.__destroyDestructible(chunkID, dmgType,
destrData,
isNeedAnimation,
explInfo)
damagedDestrs.remove(destr)
if not damagedDestrs:
self.__projectileExplosions.remove(expl)
return
itemInfo = (chunkID, itemIndex, matKind, dmgType, destrData)
self.__explodedDestructibles.append(
(BigWorld.time(), itemInfo))
BigWorld.callback(_SHOT_EXPLOSION_SYNC_TIMEOUT + 0.01,
self.__reduceExplosionCacheByTimeout)
else:
self.__destroyDestructible(chunkID, dmgType, destrData,
isNeedAnimation)
else:
entry = (dmgType, destrData, isNeedAnimation)
self.__destructiblesWaitDestroy.setdefault(chunkID,
[]).append(entry)
def enable(self, settings):
if not self.__isSupported(settings):
return []
else:
if self.__isMapDepended:
try:
mapName = BigWorld.player().arena.arenaType.geometryName
except:
LOG_CODEPOINT_WARNING()
return []
if self.__mapName != mapName:
self.__mapName = mapName
self.__create(self.__name + '_' + self.__mapName + _Effect.__FILE_EXT)
if self.__ctrl is not None:
self.__ctrl.enable()
return self.__chain
def recordVehicleDynamics(self,
scenarioName,
cmd,
isRapidMode=True,
saveTextLog=False):
if not self.avatar.inWorld:
LOG_WARNING('Avatar.base is not available yet on Avatar client')
LOG_CODEPOINT_WARNING()
return
self.scenarioName = scenarioName
self.saveTextLog = saveTextLog
self.logName = self.__generateDynamicsLogName()
cmd = cmd.strip()
zippedArg = zlib.compress(cPickle.dumps((isRapidMode, cmd)), 9)
self.__completionFlag = False
self.avatar.base.setDevelopmentFeature(0, 'record_vehicle_dynamics', 0,
zippedArg)
def __onStreamComplete(self, isSuccess, data):
if isSuccess:
if data is None:
LOG_CODEPOINT_WARNING()
isSuccess = False
else:
try:
data = zlib.decompress(data)
data = cPickle.loads(data)
except Exception:
LOG_CURRENT_EXCEPTION()
isSuccess = False
if isSuccess:
self.__callback(AccountCommands.RES_STREAM, data)
else:
self.__callback(AccountCommands.RES_FAILURE, self.__default)
return
def recordVehicleDynamics(self, scenarioName, isRapidMode = True):
if not self.avatar.inWorld:
LOG_WARNING('Avatar.base is not available yet on Avatar client')
LOG_CODEPOINT_WARNING()
return
cmd = ''
scenarioPath = self.__getScenarioFilePath(scenarioName)
if not scenarioPath:
return
scenario = open(scenarioPath, 'r')
try:
cmd = scenario.read()
finally:
scenario.close()
self.logName = self.__generateDynamicsLogName(scenarioName)
cmd = cmd.strip()
zippedArg = zlib.compress(cPickle.dumps((isRapidMode, cmd)), 9)
self.__completionFlag = False
self.avatar.base.setDevelopmentFeature('record_vehicle_dynamics', 0, zippedArg)
def decodeSegment(segment, collisionComponent):
if collisionComponent is None:
return (-1, int(segment & 255), None, None)
else:
compIdx = segment >> 8 & 255
if compIdx > 3:
LOG_CODEPOINT_WARNING(compIdx)
return (-1, int(segment & 255), None, None)
bbox = collisionComponent.getBoundingBox(compIdx)
minimum = Math.Vector3(bbox[0])
delta = (bbox[1] - minimum).scale(1.0 / 255.0)
segStart = minimum + Math.Vector3(delta[0] *
(segment >> 16 & 255), delta[1] *
(segment >> 24 & 255), delta[2] *
(segment >> 32 & 255))
segEnd = minimum + Math.Vector3(delta[0] *
(segment >> 40 & 255), delta[1] *
(segment >> 48 & 255), delta[2] *
(segment >> 56 & 255))
offset = (segEnd - segStart) * 0.01
return (compIdx, int(segment & 255), segStart - offset,
segEnd + offset)
def _start(self, data, args):
LOG_CODEPOINT_WARNING()
self.stop(data)
def __call__(self, arg1, arg2):
if self.__weakObj() is not None:
getattr(self.__weakObj(), self.__funcName)(arg1, arg2)
else:
LOG_CODEPOINT_WARNING('weak object has been already destroyed.')
return
def __call__(self, command, args):
obj = self.__weakObj()
if obj:
obj.handleExternalInterfaceCallback(command, args)
else:
LOG_CODEPOINT_WARNING('weak object has been already destroyed.')
def __call__(self, arg1, arg2):
if self.__weakObj() is not None:
getattr(self.__weakObj(), self.__funcName)(arg1, arg2)
else:
LOG_CODEPOINT_WARNING('weak object has been already destroyed.')
return# decompiled 0 files: 0 okay, 1 failed, 0 verify failed
