def __moveCameraTo(self, vehicleID, sourceVehicleID = None):
vehicle = BigWorld.entity(vehicleID)
if vehicle is None:
if vehicleID == BigWorld.player().playerVehicleID:
targetMatrix = BigWorld.player().getOwnVehicleMatrix()
self.__setCameraSettings(targetMP=targetMatrix, pivotSettings=self.__savedPivotSettings, cameraDistance=self.__savedCameraDistance, yawPitch=self.__savedYawPitch)
return True
return False
else:
targetMatrix = vehicle.matrix
self.__setCameraSettings(targetMP=targetMatrix, pivotSettings=self.__savedPivotSettings, cameraDistance=self.__savedCameraDistance, yawPitch=self.__savedYawPitch)
if sourceVehicleID is not None:
sourceVehicle = BigWorld.entity(sourceVehicleID)
if sourceVehicle is not None:
self.__savedPivotSettings = self.__arcadeCamera.getPivotSettings()
self.__savedCameraDistance = self.__arcadeCamera.getCameraDistance()
self.__savedYawPitch = self.__arcadeCamera.angles
dir = Math.Matrix(vehicle.matrix).translation - Math.Matrix(sourceVehicle.matrix).translation
yaw = dir.yaw
pitch = dir.pitch + self.KILLER_VEHICLE_PITCH_OFFSET
if pitch > math.pi * 0.5:
pitch = math.pi * 0.5
if pitch < -math.pi * 0.5:
pitch = -math.pi * 0.5
self.__setCameraSettings(pivotSettings=self.KILLER_VEHICLE_CAMERA_PIVOT_SETTINGS, cameraDistance=self.KILLER_VEHICLE_CAMERA_DISTANCE, yawPitch=(yaw, pitch))
return True
def requestEmblemByUrl(cls, url, callback):
if hasattr(BigWorld.player(), 'customFilesCache'):
if url is not None:
BigWorld.player().customFilesCache.get(url, lambda _, data: callback(data))
else:
LOG_WARNING('Trying to get emblem by url from non-account', url)
return
def __devSellInvalidVehicle(self, vehInvID, callback):
def response(code):
LOG_WARNING('Invalid vehicle selling result', vehInvID, code)
callback(code >= 0)
BigWorld.player().inventory.sellVehicle(vehInvID, True, [], [], response)
def _request(self, callback):
LOG_DEBUG('Make server request to equip tankman:', self.tankman, self.vehicle, self.slot, self.isReequip)
tmanInvID = None
if self.tankman is not None:
tmanInvID = self.tankman.invID
BigWorld.player().inventory.equipTankman(self.vehicle.invID, self.slot, tmanInvID, lambda code: self._response(code, callback))
return
def __devDismissInvalidTankmen(self, tmanInvID, callback):
def response(code):
LOG_WARNING('Invalid tankman dismissing result', tmanInvID, code)
callback(code >= 0)
BigWorld.player().inventory.dismissTankman(tmanInvID, response)
def destroy(self):
BigWorld.player().arena.onPeriodChange -= self.__arenaPeriodChanged
if self.__startEngineCbk is not None:
BigWorld.cancelCallback(self.__startEngineCbk)
self._vehicle = None
self._gearUpCbk = None
return
def find_autoaim_target(self):
auto_aim_vehicle = property(lambda self_other: BigWorld.entities.get(self_other.__autoAimVehID, None))
print('find_autoaim_target', auto_aim_vehicle)
if auto_aim_vehicle is None and BigWorld.target() is not None:
return BigWorld.target()
player = BigWorld.player()
vehicles = player.arena.vehicles
camera_dir, camera_pos = cameras.getWorldRayAndPoint(0, 0)
camera_dir.normalise()
result_len = None
las_vehicle = None
min_radian = 100000.0
for vId, vData in vehicles.items():
if vData['team'] == player.team:
continue
vehicle = BigWorld.entity(vId)
if vehicle is None or not vehicle.isStarted or not vehicle.isAlive():
continue
temp1, radian = self._calc_radian(vehicle.position, self.angle_autoaim) #1.289 градуса в радианах
if not temp1 and temp1 is not None:
continue
length = self._calc_length(vehicle.position, BigWorld.player().position)
if radian:
if result_len is None:
result_len = length
las_vehicle = vehicle
if radian < min_radian and result_len >= length:
min_radian = radian
las_vehicle = vehicle
result = las_vehicle
if result is not None:
if BigWorld.wg_collideSegment(BigWorld.player().spaceID, BigWorld.entity(result.id).appearance.modelsDesc['gun']['model'].position, camera_pos, False) is None:
return result
return BigWorld.target()
def shot(self, vehicle, attacker_id, points, effects_index):
if not (_config.data['enabled'] and self.on_off): return
if not vehicle.isStarted: return
if not vehicle.isPlayerVehicle: return
if BigWorld.player().team == BigWorld.player().arena.vehicles.get(attacker_id)['team']: return
if vehicle.health < 1: return
self.shots += 1
index_hit, decode_comp_name = DamageFromShotDecoder.decodeHitPoints(points, vehicle.typeDescriptor)
#compName = decode_comp_name[0].componentName if decode_comp_name else None
has_pierced_hit = index_hit >= VEHICLE_HIT_EFFECT.ARMOR_PIERCED
is_blocked = self.blocked_armor_hit(vehicle, decode_comp_name[0]) if decode_comp_name else False
if is_blocked:
for shell in BigWorld.player().arena.vehicles.get(attacker_id)['vehicleType'].gun['shots']:
if effects_index == shell['shell']['effectsIndex']:
type_shell = shell['shell']['kind']
if type_shell != 'HIGH_EXPLOSIVE':
self.avgDMG, _ = shell['shell']['damage']
if has_pierced_hit:
self.list[self.shots] = {
'id' : attacker_id,
'avgDMG' : self.avgDMG,
'isDamage': False,
'used' : False
}
BigWorld.callback(0.15, partial(self.shout_damage_hp, self.shots))
else: self.shout_damage()
break
else: self.clear_data()
def tryBattlesTillCaptchaReset(self):
if self.__tryReset:
return
if self.__triesLeft > 1:
self.__tryReset = True
LOG_WARNING('Client try battlesTillCaptcha reset')
BigWorld.player().challengeCaptcha('', '', lambda resultID, errorCode: None)
def __update(self):
if self.__manualSound is None:
return
elif not hasattr(BigWorld.player(), 'gunRotator'):
return
else:
p = BigWorld.player().gunRotator
if p.maxturretRotationSpeed is not None and p.maxturretRotationSpeed > 0:
self.__manualSound.setRTPC('RTPC_ext_turret_speed', p.turretRotationSpeed / p.maxturretRotationSpeed)
else:
self.__manualSound.setRTPC('RTPC_ext_turret_speed', 0)
player = BigWorld.player()
vehicleTypeDescriptor = player.vehicleTypeDescriptor
gunRotator = player.gunRotator
turretYaw = gunRotator.turretYaw
desiredShotPoint = gunRotator.predictLockedTargetShotPoint()
if desiredShotPoint is None:
desiredShotPoint = player.inputHandler.getDesiredShotPoint()
if desiredShotPoint is None:
desiredShotPoint = gunRotator.markerInfo[0]
cameraTurretYaw, _ = AimingSystems.getTurretYawGunPitch(vehicleTypeDescriptor, player.getOwnVehicleStabilisedMatrix(), desiredShotPoint, True)
angleDiff = abs(turretYaw - cameraTurretYaw)
if angleDiff > math.pi:
angleDiff = 2 * math.pi - angleDiff
self.__manualSound.setRTPC('RTPC_ext_turret_angle', angleDiff)
turretPitch = BigWorld.player().gunRotator.gunPitch
self.__manualSound.setRTPC('RTPC_ext_turret_pitch', turretPitch)
self.__manualSound.setRTPC('RTPC_ext_turret_pitch_speed', abs(self.__oldPitch - turretPitch) / (BigWorld.time() - self.__oldTime))
self.__oldPitch = turretPitch
self.__oldTime = BigWorld.time()
self.__manualSound.setRTPC('RTPC_ext_turret_damaged', 0 if BigWorld.player().deviceStates.get('turretRotator', None) is None else 1)
return self.__updatePeriod
def __calculateClosestPoint(self, start, dir):
dir.normalise()
end = start + dir.scale(10000.0)
testResTerrain = BigWorld.wg_collideSegment(BigWorld.player().spaceID, start, end, 128, 8)
terrainSuitsForCheck = testResTerrain and testResTerrain[1].dot(Math.Vector3(0.0, 1.0, 0.0)) <= math.cos(ShotPointCalculatorPlanar.TERRAIN_MIN_ANGLE)
testResNonTerrain = BigWorld.wg_collideSegment(BigWorld.player().spaceID, start, end, 136)
testResDynamic = collideDynamic(start, end, (BigWorld.player().playerVehicleID,), False)
closestPoint = None
closestDist = 1000000
isPointConvenient = True
if testResTerrain:
closestPoint = testResTerrain[0]
closestDist = (testResTerrain[0] - start).length
if terrainSuitsForCheck:
isPointConvenient = closestDist >= ShotPointCalculatorPlanar.MIN_DIST
if testResNonTerrain is not None:
dist = (testResNonTerrain[0] - start).length
if dist < closestDist:
closestPoint = testResNonTerrain[0]
closestDist = dist
isPointConvenient = closestDist >= ShotPointCalculatorPlanar.MIN_DIST
if closestPoint is None and testResDynamic is None:
return (AimingSystems.shootInSkyPoint(start, dir), True)
else:
if testResDynamic is not None:
dynDist = testResDynamic[0]
if dynDist <= closestDist:
dir = end - start
dir.normalise()
closestPoint = start + dir * dynDist
isPointConvenient = True
return (closestPoint, isPointConvenient)
def __updateSound(self, angleDiff):
if self.__manualSound is None:
return
else:
if self.__gearSound is not None and angleDiff >= _PlayerTurretRotationSoundEffect.__MIN_ANGLE_TO_ENABLE_GEAR:
if self.__currentSpeedState != self.__SPEED_FAST and self.__currentSpeedState != self.__SPEED_PRE_FAST:
nextSpeedState = self.__SPEED_PRE_FAST
else:
nextSpeedState = self.__currentSpeedState
elif angleDiff >= _PlayerTurretRotationSoundEffect.__MIN_ANGLE_TO_ENABLE_MANUAL:
nextSpeedState = self.__SPEED_SLOW
else:
nextSpeedState = self.__SPEED_IDLE
stateFn = self.__stateTable[self.__currentSpeedState][nextSpeedState]
if stateFn is not None:
stateFn()
self.__currentSpeedState = nextSpeedState
if g__attachToCam:
__p = BigWorld.camera().position
else:
__p = BigWorld.player().position
isTurretAlive = BigWorld.player().deviceStates.get('turretRotator', None) is None
if self.__gearDamagedParam is not None:
self.__gearDamagedParam.value = 0.0 if isTurretAlive else 1.0
if self.__manGearDamagedParam is not None:
self.__manGearDamagedParam.value = 0.0 if isTurretAlive else 1.0
if self.__manualSound is not None:
self.__manualSound.position = __p
if self.__gearSound is not None:
self.__gearSound.position = __p
return
def __init_sound(self):
if BigWorld.player() is not None and BigWorld.player().getVehicleAttached() is not None:
self.connectSoundToMatrix(BigWorld.player().getVehicleAttached().appearance.modelsDesc['turret']['model'].matrix)
else:
self.connectSoundToMatrix(mathUtils.createIdentityMatrix())
self.delayCallback(self.__updatePeriod, self.__update)
return
def onCameraChanged(self, cameraMode, curVehID = None):
LOG_DEBUG('onCameraChanged', cameraMode, curVehID)
if self.__cameraMode == 'mapcase':
self.setAimingMode(False)
elif cameraMode == 'mapcase':
self.setAimingMode(True)
self.__cameraMode = cameraMode
def setVisible(cname):
m = self.getMember(cname)
if m is not None:
m.visible = cameraMode != 'video'
return
if self.__isGuiShown():
self.damagePanel.showAll(cameraMode != 'video')
setVisible('vehicleMessagesPanel')
setVisible('vehicleErrorsPanel')
if cameraMode == 'video':
self.__cameraVehicleID = -1
self.__vErrorsPanel.clear()
self.__vMsgsPanel.clear()
self._hideVehicleTimer('ALL')
self.hideDeathzoneTimer('ALL')
aim = BigWorld.player().inputHandler.aim
if aim is not None:
aim.updateAmmoState(True)
aim = BigWorld.player().inputHandler.aim
if aim is not None:
aim.onCameraChange()
return
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 destroy(self):
BigWorld.player().inputHandler.onCameraChanged -= self.__onCameraChanged
self.__ballistics = None
for shotID in self.__projectiles.keys():
self.__delProjectile(shotID)
return
def add(self, shotID, effectsDescr, gravity, refStartPoint, refVelocity, startPoint, maxDistance, isOwnShoot = False, tracerCameraPos = Math.Vector3(0, 0, 0)):
import BattleReplay
if BattleReplay.g_replayCtrl.isTimeWarpInProgress:
return
else:
artID = effectsDescr.get('artilleryID')
if artID is not None:
self.salvo.addProjectile(artID, gravity, refStartPoint, refVelocity)
return
projectileMotor = self.__ballistics.addProjectile(shotID, gravity, refStartPoint, refVelocity, startPoint, maxDistance, isOwnShoot, ownVehicleGunPositionGetter(), tracerCameraPos)
if projectileMotor is None:
return
projModelName, projModelOwnShotName, projEffects = effectsDescr['projectile']
model = BigWorld.Model(projModelOwnShotName if isOwnShoot else projModelName)
proj = {'model': model,
'motor': projectileMotor,
'effectsDescr': effectsDescr,
'showExplosion': False,
'fireMissedTrigger': isOwnShoot,
'autoScaleProjectile': isOwnShoot,
'effectsData': {}}
BigWorld.player().addModel(model)
model.addMotor(projectileMotor)
model.visible = False
model.visibleAttachments = True
projEffects.attachTo(proj['model'], proj['effectsData'], 'flying')
self.__projectiles[shotID] = proj
FlockManager.getManager().onProjectile(startPoint)
return
def new_brf_format(self, message, *args):
result = old_brf_format(self, message, *args)
arenaUniqueID = message.data.get('arenaUniqueID', 0)
stat.queue.put(arenaUniqueID)
if stat.config.get('enableBattleEndedMessage', True) and hasattr(BigWorld.player(), 'arena'):
if BigWorld.player().arena.arenaUniqueID != arenaUniqueID:
isWinner = message.data.get('isWinner', 0)
battleEndedMessage = ''
if isWinner < 0:
battleEndedMessage = stat.config.get('battleEndedMessageDefeat', '')
elif isWinner > 0:
battleEndedMessage = stat.config.get('battleEndedMessageWin', '')
else:
battleEndedMessage = stat.config.get('battleEndedMessageDraw', '')
battleEndedMessage = battleEndedMessage.encode('utf-8')
vehicleCompDesc = message.data.get('vehTypeCompDescr', None)
vt = vehiclesWG.getVehicleType(vehicleCompDesc)
battleEndedMessage = battleEndedMessage.replace('{{vehicle}}', vt.userString)
name = vt.name.replace(':', '-')
battleEndedMessage = battleEndedMessage.replace('{{vehicle-name}}', name)
arenaTypeID = message.data.get('arenaTypeID', 0)
arenaType = ArenaType.g_cache[arenaTypeID]
arenaName = i18n.makeString(arenaType.name)
battleEndedMessage = battleEndedMessage.replace('{{map}}', arenaName)
battleEndedMessage = battleEndedMessage.replace('{{map-name}}', arenaType.geometryName)
MessengerEntry.g_instance.gui.addClientMessage(battleEndedMessage)
return result
def change(self, vehInvID, section, isAlreadyPurchased):
if self._newItemID is None:
message = i18n.makeString(SYSTEM_MESSAGES.CUSTOMIZATION_INSCRIPTION_NOT_SELECTED)
self.onCustomizationChangeFailed(message)
return
if self._rentalPackageDP.selectedPackage is None:
message = i18n.makeString(SYSTEM_MESSAGES.CUSTOMIZATION_INSCRIPTION_DAYS_NOT_SELECTED)
self.onCustomizationChangeFailed(message)
return
cost, isGold = self._itemsDP.getCost(self._newItemID)
if cost < 0:
message = i18n.makeString(SYSTEM_MESSAGES.CUSTOMIZATION_INSCRIPTION_COST_NOT_FOUND)
self.onCustomizationChangeFailed(message)
return
if isAlreadyPurchased:
daysToWear = 0
cost = 0
elif CustomizationHelper.isItemInHangar(CUSTOMIZATION_ITEM_TYPE.INSCRIPTION, self._newItemID, self._nationID, self._itemsDP.position):
hangarItem = CustomizationHelper.getItemFromHangar(CUSTOMIZATION_ITEM_TYPE.INSCRIPTION_TYPE, self._newItemID)
daysToWear = 0 if hangarItem.get('isPermanent') else 7
else:
daysToWear = self._rentalPackageDP.selectedPackage.get('periodDays')
newIdToSend = 0
isNewInDefaultSetup = False
isCurrIgr = self._itemsDP.isIGRItem(self._currentItemID)
if isCurrIgr:
isNewInDefaultSetup = CustomizationHelper.isIdInDefaultSetup(CUSTOMIZATION_ITEM_TYPE.INSCRIPTION, self._newItemID)
if self._currentItemID is None or not isCurrIgr or isCurrIgr and not isNewInDefaultSetup or isCurrIgr and isNewInDefaultSetup and daysToWear > 0:
newIdToSend = self._newItemID
BigWorld.player().inventory.changeVehicleInscription(vehInvID, self.getRealPosition(), newIdToSend, daysToWear, 1, lambda resultID: self.__onChangeVehicleInscription(resultID, (cost, isGold)))
def __init__(self, reason = None, isBan = False, expiryTime = None):
super(DisconnectMeta, self).__init__('disconnected', scope=ScopeTemplates.GLOBAL_SCOPE)
self.reason = reason
self.isBan = isBan
self.expiryTime = expiryTime
if hasattr(BigWorld.player(), 'setForcedGuiControlMode'):
BigWorld.player().setForcedGuiControlMode(True)
def mainLoop(self):
while True:
arenaUniqueID = self.queue.get()
stat.battleResultsAvailable.wait()
self.battleResultsBusy.acquire()
shotBRCallback = partial(self.battleResultsCallback, arenaUniqueID)
BigWorld.player().battleResultsCache.get(arenaUniqueID, shotBRCallback)
def showDamageFromShot(self, attackerID, points, effectsIndex):
if not self.isStarted:
return
effectsDescr = vehicles.g_cache.shotEffects[effectsIndex]
maxHitEffectCode, decodedPoints = DamageFromShotDecoder.decodeHitPoints(points, self.typeDescriptor)
hasPiercedHit = DamageFromShotDecoder.hasDamaged(maxHitEffectCode)
for shotPoint in decodedPoints:
showFullscreenEffs = self.isPlayer and self.isAlive()
keyPoints, effects, _ = effectsDescr[shotPoint.hitEffectGroup]
self.appearance.modelsDesc[shotPoint.componentName]['boundEffects'].addNew(shotPoint.matrix, effects, keyPoints, isPlayer=self.isPlayer, showShockWave=showFullscreenEffs, showFlashBang=showFullscreenEffs, entity_id=self.id)
if decodedPoints:
firstHitPoint = decodedPoints[0]
compMatrix = Math.Matrix(self.appearance.modelsDesc[firstHitPoint.componentName]['model'].matrix)
firstHitDirLocal = firstHitPoint.matrix.applyToAxis(2)
firstHitDir = compMatrix.applyVector(firstHitDirLocal)
self.appearance.receiveShotImpulse(firstHitDir, effectsDescr['targetImpulse'])
self.appearance.executeHitVibrations(maxHitEffectCode)
player = BigWorld.player()
player.inputHandler.onVehicleShaken(self, compMatrix.translation, firstHitDir, effectsDescr['caliber'], ShakeReason.HIT if hasPiercedHit else ShakeReason.HIT_NO_DAMAGE)
self.__hitType = effectsIndex
if not hasPiercedHit:
self.damage_announce(attackerID, 0)
if not self.isAlive():
return
if attackerID == BigWorld.player().playerVehicleID and maxHitEffectCode is not None and not self.isPlayer:
marker = getattr(self, 'marker', None)
if marker is not None:
manager = g_windowsManager.battleWindow.markersManager
manager.updateMarkerState(marker, 'hit_pierced' if hasPiercedHit else 'hit')
def __cb_onGetTutorialsCompleted(self, resultID, completed):
ctx = self._ctx
loader = self._loader
if resultID < RES_SUCCESS:
LOG_ERROR('Server return error on request tutorialsCompleted', resultID, completed)
loader._clear()
self._clear()
return
ctx.bonusCompleted = completed
cache = ctx.cache
if loader.tutorial._descriptor.areAllBonusesReceived(completed):
cache.setFinished(True).write()
loader._clear()
self._clear()
return
if cache.isRefused():
self._clear()
if ctx.restart and not ctx.isInPrebattle:
loader.tutorial.restart(ctx)
else:
loader.tutorial.pause(ctx)
return
if cache.isEmpty() and not completed:
BigWorld.player().stats.get('dossier', self.__cb_onGetDossier)
else:
self._clear()
if not cache.isAfterBattle():
cache.setAfterBattle(loader.isAfterBattle)
loader._doRun(ctx)
def handleKeyEvent(self, event):
cursorDetached = self.__detachCount < 0
import game
(isDown, key, mods, isRepeat,) = game.convertKeyEvent(event)
if isRepeat:
return False
if self.__isStarted and cursorDetached:
return BigWorld.player().handleKey(isDown, key, mods)
if not self.__isStarted or cursorDetached:
return False
if isDown and BigWorld.isKeyDown(Keys.KEY_CAPSLOCK):
if self.__alwaysShowAimKey is not None and key == self.__alwaysShowAimKey:
self.__alwaysShowAim = not self.__alwaysShowAim
getAim = getattr(self.__curCtrl, 'getAim')
if getAim is not None:
aim = getAim()
if aim is not None:
aim.setVisible(self.__alwaysShowAim or BigWorld.player().isGuiVisible)
return True
if self.__showMarkersKey is not None and key == self.__showMarkersKey and not BigWorld.player().isGuiVisible:
from gui.WindowsManager import g_windowsManager
markersManager = g_windowsManager.battleWindow.vMarkersManager
markersManager.active(not markersManager.isActive)
return True
if key == Keys.KEY_F5 and constants.IS_DEVELOPMENT:
self.__vertScreenshotCamera.enable(not self.__vertScreenshotCamera.isEnabled)
return True
if self.__curCtrl.handleKeyEvent(isDown, key, mods, event):
return True
return BigWorld.player().handleKey(isDown, key, mods)
def create(self, mapName):
global _V_START_POS
global _V_START_ANGLES
try:
LOG_DEBUG('OfflineMapCreator.Create( %s )' % mapName)
g_appLoader.showBattle()
cfgType = 'basic'
self.__loadCfg(cfgType, mapName)
BigWorld.worldDrawEnabled(False)
BigWorld.setWatcher('Visibility/GUI', False)
self.__spaceId = BigWorld.createSpace()
self.__isActive = True
self.__arenaTypeID = self._arenaTypeIDByArenaName.get(mapName)
self.__accountID = BigWorld.createEntity('Account', self.__spaceId, 0, _V_START_POS, (_V_START_ANGLES[2], _V_START_ANGLES[1], _V_START_ANGLES[0]), dict())
self.__spaceMappingId = BigWorld.addSpaceGeometryMapping(self.__spaceId, None, 'spaces/' + mapName)
self.__vEntityId = BigWorld.createEntity('Avatar', self.__spaceId, 0, _V_START_POS, (_V_START_ANGLES[2], _V_START_ANGLES[1], _V_START_ANGLES[0]), dict())
BigWorld.player(BigWorld.entities[self.__vEntityId])
self.__setupCamera()
BigWorld.worldDrawEnabled(True)
except:
LOG_DEBUG('OfflineMapCreator.Create( %s ): FAILED with: ' % mapName)
LOG_CURRENT_EXCEPTION()
self.cancel()
return
def _request(self, callback):
BigWorld.player().inventory.setAndFillLayouts(
self.vehicle.invID,
self.shellsLayout,
self.eqsLayout,
lambda code, errStr, ext: self._response(code, callback, errStr=errStr, ctx=ext),
)
def teleportNext(timer, destinationList):
dest = destinationList[0]
BigWorld.player().tryToTeleport(dest[0], dest[1])
if len(destinationList) > 1:
BigWorld.callback(timer, partial(teleportNext, timer, destinationList[1:]))
else:
print 'teleport test finished'
def _request(self, callback):
itemCD = self.item.intCD if self.install else 0
newEqsLayout = map(lambda item: (item.intCD if item is not None else 0), self.vehicle.eqs)
newEqsLayout[self.slotIdx] = itemCD
BigWorld.player().inventory.equipEquipments(
self.vehicle.invID, newEqsLayout, lambda code: self._response(code, callback)
)
def _request(self, callback):
LOG_DEBUG('Make server request to retrain Crew:', self.tankmen, self.vehicle, self.tmanCostTypeIdx)
tMenInvIDsAndCostTypeIdx = []
for tManInvID in self.tankmen:
tMenInvIDsAndCostTypeIdx.append((tManInvID, self.tmanCostTypeIdx))
BigWorld.player().inventory.multiRespecTankman(tMenInvIDsAndCostTypeIdx, self.vehicle.intCD, lambda code: self._response(code, callback))
def startVisual(self):
assert not self.isStarted
avatar = BigWorld.player()
self.appearance.preStart(self.typeDescriptor)
self.appearance.start(self, self.__prereqs)
self.__prereqs = None
self.appearance.changeEngineMode(self.engineMode)
self.appearance.onVehicleHealthChanged()
if self.isPlayer:
if self.isAlive():
BigWorld.wgAddEdgeDetectEntity(self, 0, 1, True)
self.appearance.setupGunMatrixTargets(avatar.gunRotator)
else:
self.marker = g_windowsManager.battleWindow.markersManager.createMarker(self.proxy)
if hasattr(self.filter, 'allowStrafeCompensation'):
self.filter.allowStrafeCompensation = not self.isPlayer
self.isStarted = True
self.set_publicStateModifiers()
self.set_damageStickers()
if not self.isAlive():
self.__onVehicleDeath(True)
if self.isTurretMarkedForDetachment:
self.confirmTurretDetachment()
minimap = g_windowsManager.battleWindow.minimap
minimap.notifyVehicleStart(self.id)
self.__startWGPhysics()
if self is BigWorld.player().getVehicleAttached():
nationId = self.typeDescriptor.type.id[0]
SoundGroups.g_instance.soundModes.setCurrentNation(nations.NAMES[nationId])
def requestUserlistByName(self, name, maxCount, callback):
reqID = self.__addRequest(MESSENGER_TIMEOUTS.GET_USERLIST_BY_NAME,
partial(_onUserlistResult, callback))
BigWorld.player().base.messenger_onActionByClient(
MESSENGER_ACTION_IDS.GET_USERLIST_BY_NAME, reqID,
makeArgs(int32Arg1=maxCount, strArg1=name))
def isInTutorialQueue():
return getattr(BigWorld.player(), 'isInTutorialQueue', False)
def isInRandomQueue():
return getattr(BigWorld.player(), 'isInRandomQueue', False)
def forceStart(self):
currPlayer = BigWorld.player()
if currPlayer is not None and hasattr(currPlayer, 'forceEpicDevStart'):
currPlayer.forceEpicDevStart()
return
def forceStart(self):
currPlayer = BigWorld.player()
if currPlayer is not None and hasattr(currPlayer,
'createArenaFromQueue'):
currPlayer.createArenaFromQueue()
return
def databaseID(self):
return BigWorld.player(
).databaseID if not self.isDisconnected() else None
def __isNY():
player = BigWorld.player()
if not hasattr(player, 'newYear'):
return False
return player.newYear.state == NY_STATE.IN_PROGRESS
def getInitParams(self):
BigWorld.player().base.messenger_onActionByClient(
MESSENGER_ACTION_IDS.GET_INIT_PARAMS, 0, makeArgs())
def onLeaveArena(self):
self.__isOnArena = False
BigWorld.player().arena.onPeriodChange -= self.__onArenaStateChanged
def syncClanChatChannel(self, callback):
reqID = self.__addRequest(MESSENGER_TIMEOUTS.SYNC_CLAN_CHAT_CHANNEL,
partial(_onInt32Result, callback))
BigWorld.player().base.messenger_onActionByClient(
MESSENGER_ACTION_IDS.SYNC_CLAN_CHAT_CHANNEL, reqID, makeArgs())
def onGUISpaceEntered(spaceID):
if spaceID == GUI_GLOBAL_SPACE_ID.BATTLE:
cleanup()
for vehicleID, vData in BigWorld.player().arena.vehicles.iteritems():
if vData['vehicleType']:
update_hp(vehicleID, vData['vehicleType'].maxHealth)
def requestXmppPassword(self, callback):
reqID = self.__addRequest(MESSENGER_TIMEOUTS.XMPP_GET_PASSWORD,
partial(_onStringResult, callback))
BigWorld.player().base.messenger_onActionByClient(
MESSENGER_ACTION_IDS.XMPP_GET_PASSWORD, reqID, makeArgs())
def _request(self, callback):
LOG_DEBUG('Make server request to buy premium account', self.period,
self.premiumPrice)
BigWorld.player().stats.upgradeToPremium(
self.period, self.arenaUniqueID,
lambda code: self._response(code, callback))
def onEnterArena(self):
BigWorld.player().arena.onPeriodChange += self.__onArenaStateChanged
self.__isOnArena = True
self.__onArenaStateChanged()
def _request(self, callback):
LOG_DEBUG('Make server request to exchange xp for credits')
BigWorld.player().stats.convertToFreeXP(
self.vehiclesCD, self.xp,
lambda code: self._response(code, callback),
int(self.__freeConversion))
def __create(self):
self.__areaVisual = BigWorld.PyTerrainSelectedArea()
self.__model = BigWorld.Model('')
BigWorld.player().addModel(self.__model)
def onLeaveWorld(self):
self.__stopExtras()
BigWorld.player().vehicle_onLeaveWorld(self)
raise not self.isStarted or AssertionError
def _request(self, callback):
LOG_DEBUG('Make server request to buy tankman berths')
BigWorld.player().stats.buyBerths(
lambda code: self._response(code, callback))
def isPlayerTeam(self):
return self.team == BigWorld.player().team
def _request(self, callback):
LOG_DEBUG('Make server request to exchange gold to credits')
BigWorld.player().stats.exchange(
self.gold, lambda code: self._response(code, callback))
def _disposeBombTarget(self):
self._proxyPlayer.eSetBombTargetVisible -= self.__bombTarget.setBombTargetVisible
BigWorld.player().eLeaveWorldEvent -= self._disposeBombTarget
self.__bombTarget.dispose()
self.__bombTarget = None
return
def playerVehicle(self):
player = BigWorld.player()
return self.createVehicle(player.name)
def hideCursor(self):
Cursor.forceShowCursor(False)
entity = BigWorld.player()
entity.setFlyMouseInputAllowed(True)
def getShotResult(cls, hitPoint, collision, dir, excludeTeam=0):
""" Gets shot result by present state of gun marker.
:param hitPoint: Vector3 containing shot position.
:param collision: instance of EntityCollisionData.
:param excludeTeam: integer containing number of team that is excluded from result.
:return: one of SHOT_RESULT.*.
"""
if collision is None:
return _SHOT_RESULT.UNDEFINED
else:
entity = collision.entity
if entity.__class__.__name__ != 'Vehicle':
return _SHOT_RESULT.UNDEFINED
if entity.health <= 0 or entity.publicInfo['team'] == excludeTeam:
return _SHOT_RESULT.UNDEFINED
player = BigWorld.player()
if player is None:
return _SHOT_RESULT.UNDEFINED
vDesc = player.getVehicleDescriptor()
shell = vDesc.shot.shell
caliber = shell.caliber
shellKind = shell.kind
ppDesc = vDesc.shot.piercingPower
maxDist = vDesc.shot.maxDistance
dist = (hitPoint - player.getOwnVehiclePosition()).length
piercingPower = cls._computePiercingPowerAtDist(
ppDesc, dist, maxDist)
fullPiercingPower = piercingPower
minPP, maxPP = cls._computePiercingPowerRandomization(shell)
result = _SHOT_RESULT.NOT_PIERCED
isJet = False
jetStartDist = None
ignoredMaterials = set()
collisionsDetails = cls._getAllCollisionDetails(
hitPoint, dir, entity)
if collisionsDetails is None:
return _SHOT_RESULT.UNDEFINED
for cDetails in collisionsDetails:
if isJet:
jetDist = cDetails.dist - jetStartDist
if jetDist > 0.0:
piercingPower *= 1.0 - jetDist * cls._SHELL_EXTRA_DATA[
shellKind].jetLossPPByDist
if cDetails.matInfo is None:
result = cls._CRIT_ONLY_SHOT_RESULT
else:
matInfo = cDetails.matInfo
if (cDetails.compName, matInfo.kind) in ignoredMaterials:
continue
hitAngleCos = cDetails.hitAngleCos if matInfo.useHitAngle else 1.0
if not isJet and cls._shouldRicochet(
shellKind, hitAngleCos, matInfo, caliber):
break
piercingPercent = 1000.0
if piercingPower > 0.0:
penetrationArmor = cls._computePenetrationArmor(
shellKind, hitAngleCos, matInfo, caliber)
piercingPercent = 100.0 + (
penetrationArmor -
piercingPower) / fullPiercingPower * 100.0
piercingPower -= penetrationArmor
if matInfo.vehicleDamageFactor:
if minPP < piercingPercent < maxPP:
result = _SHOT_RESULT.LITTLE_PIERCED
elif piercingPercent <= minPP:
result = _SHOT_RESULT.GREAT_PIERCED
break
elif matInfo.extra:
if piercingPercent <= maxPP:
result = cls._CRIT_ONLY_SHOT_RESULT
if matInfo.collideOnceOnly:
ignoredMaterials.add((cDetails.compName, matInfo.kind))
if piercingPower <= 0.0:
break
if cls._SHELL_EXTRA_DATA[shellKind].jetLossPPByDist > 0.0:
isJet = True
mInfo = cDetails.matInfo
armor = mInfo.armor if mInfo is not None else 0.0
jetStartDist = cDetails.dist + armor * 0.001
return result
def freeXPToTankman(self, tankmanId, freeXp, callback):
BigWorld.player().inventory.freeXPToTankman(
tankmanId, freeXp, lambda eStr, code: self.__callback(
(code >= 0, eStr)))
def _initBombTarget(self):
self.__bombTarget = BombTargetHolder(self._proxyPlayer)
self.__bombTarget.initBombTarget()
self._proxyPlayer.eSetBombTargetVisible += self.__bombTarget.setBombTargetVisible
BigWorld.player().eLeaveWorldEvent += self._disposeBombTarget
def getCredits(self, callback):
BigWorld.player().stats.get('credits', self.__valueResponse)
def reset(self):
self.playerTeam = BigWorld.player().team
self.mainCaliberValue = 0
self.hpDict = {}
self.aliveDict = {}
def getTankmanDossier(self, tankmanID, callback):
BigWorld.player().inventory.getItems(
_TANKMAN, partial(self.__tankmanDossierResponse, tankmanID))
def getFreeXPToTManXPRate(self, callback):
BigWorld.player().shop.getFreeXPToTManXPRate(self.__valueResponse)
