def effarmorpanel_sqrt_y():
if ME_Tank.tankType == "TD":
APsqrty = config.get("armorPanel/eAP/ordinateWhenTD", 0.70) * (BigWorld.screenHeight() / 2) + 1.0
elif ME_Tank.tankType == "SPG":
APsqrty = config.get("armorPanel/protractor/ordinateWhenSPG", 0) * (BigWorld.screenHeight() / 2) + 1.0
else:
APsqrty = (config.get("armorPanel/eAP/ordinateWhenTank", 0.8) * (BigWorld.screenHeight() / 2)) + 1.0
return APsqrty
def updateResolutionOverride(self):
webPageWidth, webPageHeight = Utils.pixelSize(self.component)
screenWidth = BigWorld.screenWidth()
screenHeight = BigWorld.screenHeight()
usedResolutionOverride = GUI.screenResolution()
if usedResolutionOverride != (0, 0):
webPageWidth *= BigWorld.screenWidth() / usedResolutionOverride[0]
webPageHeight *= BigWorld.screenHeight() / usedResolutionOverride[1]
self.webPage.setSize(webPageWidth, webPageHeight, self.exactWidth, self.exactHeight)
def updateResolutionOverride(self):
webPageWidth, webPageHeight = Utils.pixelSize(self.component)
screenWidth = BigWorld.screenWidth()
screenHeight = BigWorld.screenHeight()
usedResolutionOverride = GUI.screenResolution()
if usedResolutionOverride != (0, 0):
webPageWidth *= BigWorld.screenWidth() / usedResolutionOverride[0]
webPageHeight *= BigWorld.screenHeight() / usedResolutionOverride[1]
self.webPage.setSize(webPageWidth, webPageHeight, self.exactWidth, self.exactHeight)
def effarmorpanel_sqrt_y():
if ME_Tank.tankType == "TD":
APsqrty = config.get("armorPanel/eAP/ordinateWhenTD",
0.70) * (BigWorld.screenHeight() / 2) + 1.0
elif ME_Tank.tankType == "SPG":
APsqrty = config.get("armorPanel/protractor/ordinateWhenSPG",
0) * (BigWorld.screenHeight() / 2) + 1.0
else:
APsqrty = (config.get("armorPanel/eAP/ordinateWhenTank", 0.8) *
(BigWorld.screenHeight() / 2)) + 1.0
return APsqrty
def currentRadius(self):
player = BigWorld.player()
planeDir = BigWorld.player().getRotation().getAxisZ()
self._Q.fromAngleAxis(self._lastCorrectMaxAngle,
BigWorld.player().getRotation().getAxisX())
Dir = self._Q.rotateVec(planeDir)
reductionPointVector = getReductionPointVector(player.weaponsSettings)
worldPos = Dir * reductionPointVector.length * HUD_REDUCTION_POINT_SCALE + player.position
screenPoint = BigWorld.worldToScreen(worldPos)
screenPoint = Math.Vector3(
clamp(0.0, screenPoint.x, BigWorld.screenWidth()),
clamp(0.0, screenPoint.y, BigWorld.screenHeight()), 1.0)
x = screenPoint.x - 0.5 * BigWorld.screenWidth()
y = -screenPoint.y + 0.5 * BigWorld.screenHeight()
return math.hypot(x, y)
def __onMenuShow(self, mouseUsedForShow):
if not self.__ingameMenuIsVisible():
screenWidth = BigWorld.screenWidth()
screenHeight = BigWorld.screenHeight()
guiScreenWidth, guiScreenHeight = GUI.screenResolution()
ratioWidth = float(guiScreenWidth / screenWidth)
ratioHeight = float(guiScreenHeight / screenHeight)
self.call('RadialMenu.setRatio', [ratioWidth, ratioHeight])
crosshairType = self.__getCrosshairType()
keys = self.__getKeysList(crosshairType)
self.GUICtrl.setFireKeyCode(self.__getFireKeyCode())
self.GUICtrl.setState(crosshairType)
self.GUICtrl.updateKeys(keys)
screenWidth, screenHeight = GUI.screenResolution()
ctrl = g_sessionProvider.shared.crosshair
if ctrl is not None:
mouseLeft, mouseTop = ctrl.getOffset()
else:
mouseLeft, mouseTop = (0.0, 0.0)
x = round(screenWidth / 2.0 * mouseLeft)
y = -round(screenHeight / 2.0 * mouseTop)
offset = (x, y)
self.__showed = True
self.GUICtrl.show(offset, mouseUsedForShow)
return
def new_RadialMenu_show(self):
player = BigWorld.player()
target = BigWorld.target()
# Target substitution begins.
config = g_config['plugins']['radialMenu']
if target is None and config['useTargetScan']:
targetScanner = getattr(player.inputHandler, 'XTargetScanner', None)
if targetScanner is not None:
target = targetScanner.scanTarget().target
if target is None and config['useTargetInfo']:
targetInfo = getattr(player.inputHandler, 'XTargetInfo', None)
if targetInfo is not None and not targetInfo.isExpired:
target = targetInfo.getVehicle()
# Target substitution ends.
self._RadialMenu__targetID = target.id if target is not None else None
ctrl = self.sessionProvider.shared.crosshair
guiScreenWidth, guiScreenHeight = GUI.screenResolution()
screenRatio = float(guiScreenWidth / BigWorld.screenWidth()), float(
guiScreenHeight / BigWorld.screenHeight())
screenPosition = ctrl.getDisaredPosition() if ctrl is not None else (
guiScreenWidth * 0.5, guiScreenHeight * 0.5)
crosshairType = self._RadialMenu__getCrosshairType(player, target)
if self.app is not None:
self.app.registerGuiKeyHandler(self)
self.as_showS(crosshairType, screenPosition, screenRatio)
return
def __init__(self):
self.rotation = 0
self.showInArcade = config.get('armorPanel/protractor/showInArcade',
False)
self.useCameraRotation = config.get(
'armorPanel/protractor/useCameraRotation', True)
self.circle_xscale = 1
self.circle_x = 0
self.atRMax = False
self.atLMax = False
self.middleLine_x = 0
self.x = None
self.y = None
self.useProtractorTD = False
self.useProtractorSPG = False
self.rightArc = None
self.heightSPG = 0.0
self.midX = BigWorld.screenWidth() / 2
self.midY = BigWorld.screenHeight() / 2
self.leftArc = None
self.enable = False
self.realMidLine_right_alpha = 0.0
self.realMidLine_left_alpha = 0.0
self.leftLine_x = 0
self.mask_x = 0
self.rightLine_x = 0
self.mask_width = 0
self.middleLine_txt_text = ""
self.leftLine_img = "LeftLine"
self.rightLine_img = "RightLine"
self.middleLine_img = "middleLine"
self.xSpacing = config.get('armorPanel/protractor/xSpacing', 0)
# self.m2pix = config.get('armorPanel/protractor/m2pix', 40.4761904762)
self.protractorOffsetWhenTD = config.get(
'armorPanel/protractor/protractorOffsetWhenTD', 43)
def __onMenuShow(self, mouseUsedForShow):
if not self.__ingameMenuIsVisible():
screenWidth = BigWorld.screenWidth()
screenHeight = BigWorld.screenHeight()
guiScreenWidth, guiScreenHeight = GUI.screenResolution()
ratioWidth = float(guiScreenWidth / screenWidth)
ratioHeight = float(guiScreenHeight / screenHeight)
self.call('RadialMenu.setRatio', [ratioWidth, ratioHeight])
crosshairType = self.__getCrosshairType()
keys = self.__getKeysList(crosshairType)
self.GUICtrl.setFireKeyCode(self.__getFireKeyCode())
self.GUICtrl.setState(crosshairType)
self.GUICtrl.updateKeys(keys)
screenWidth, screenHeight = GUI.screenResolution()
ctrl = g_sessionProvider.shared.crosshair
if ctrl is not None:
mouseLeft, mouseTop = ctrl.getOffset()
else:
mouseLeft, mouseTop = (0.0, 0.0)
x = round(screenWidth / 2.0 * mouseLeft)
y = -round(screenHeight / 2.0 * mouseTop)
offset = (x, y)
self.__showed = True
self.GUICtrl.show(offset, mouseUsedForShow)
return
def onEnterWorld(self, prereqs):
if self.isPlayerVehicle:
global yaw, old_yaw, pitch, old_pitch, old_multiplier, dataHor, dataVert, turretYawLimits, scaleHor, scaleVert
global minStep, maxPitch, minPitch, currentStep, minBound, maxBound, screenHeight, screenWidth, player
global old_gunAnglesPacked, isAlive, cameraMode
player = BigWorld.player()
yaw = 0.0
pitch = 0.0
old_multiplier = 1.0
old_gunAnglesPacked = None
old_yaw = None
old_pitch = None
isAlive = self.isAlive
screenHeight = BigWorld.screenHeight()
screenWidth = BigWorld.screenWidth()
currentStep = STEP
verticalFov = FovExtended.instance().actualDefaultVerticalFov
horizontalFov = FovExtended.calcHorizontalFov(verticalFov)
scaleHor = screenWidth / horizontalFov if horizontalFov else screenWidth
scaleVert = screenHeight / verticalFov if verticalFov else screenHeight
gun = self.typeDescriptor.gun
minBound, maxBound = gun['pitchLimits']['absolute']
minStep = (maxBound - minBound) / 63
turretYawLimits = gun['turretYawLimits']
maxPitch =gun['pitchLimits']['maxPitch']
minPitch = gun['pitchLimits']['minPitch']
dataHor, dataVert = coordinate(yaw, pitch)
cameraMode = None
as_event('ON_ANGLES_AIMING')
def __init__(self):
self.rotation = 0
self.showInArcade = config.get('armorPanel/protractor/showInArcade', False)
self.useCameraRotation = config.get('armorPanel/protractor/useCameraRotation', True)
self.circle_xscale = 1
self.circle_x = 0
self.atRMax = False
self.atLMax = False
self.middleLine_x = 0
self.x = None
self.y = None
self.useProtractorTD = False
self.useProtractorSPG = False
self.rightArc = None
self.heightSPG = 0.0
self.midX = BigWorld.screenWidth() / 2
self.midY = BigWorld.screenHeight() / 2
self.leftArc = None
self.enable = False
self.realMidLine_right_alpha = 0.0
self.realMidLine_left_alpha = 0.0
self.leftLine_x = 0
self.mask_x = 0
self.rightLine_x = 0
self.mask_width = 0
self.middleLine_txt_text = ""
self.leftLine_img = "LeftLine"
self.rightLine_img = "RightLine"
self.middleLine_img = "middleLine"
self.xSpacing = config.get('armorPanel/protractor/xSpacing', 0)
# self.m2pix = config.get('armorPanel/protractor/m2pix', 40.4761904762)
self.protractorOffsetWhenTD = config.get('armorPanel/protractor/protractorOffsetWhenTD', 43)
def __resultGPU(self, name, result):
cur = BigWorld.screenWidth() * BigWorld.screenHeight()
hd = 2073600.0
k = math.sqrt(hd / cur)
rating = int(result * k)
debug_utils.LOG_INFO(
'GPU benchmark result:{0}, k:{1}, rating:{2}'.format(
result, k, rating))
return self.__resultCB(name, rating)
def enable(self, doEnable):
if self.__isEnabled == doEnable:
return
from cameras import FovExtended
if not doEnable:
self.__isEnabled = False
BigWorld.camera(self.__savedCamera)
BigWorld.wg_enableSuperShot(False, False)
for k, v in self.__savedWatchers.iteritems():
BigWorld.setWatcher(k, v)
FovExtended.instance().enabled = True
LOG_DEBUG('Vertical screenshot camera is disabled')
return
self.__isEnabled = True
self.__savedCamera = BigWorld.camera()
FovExtended.instance().enabled = False
arenaBB = BigWorld.wg_getSpaceBounds()
centerXZ = Math.Vector2(0.5 * (arenaBB[0] + arenaBB[2]),
0.5 * (arenaBB[1] + arenaBB[3]))
halfSizesXZ = Math.Vector2(0.5 * (arenaBB[2] - arenaBB[0]),
0.5 * (arenaBB[3] - arenaBB[1]))
camFov = math.radians(15.0)
camPos = Math.Vector3(centerXZ.x, 0, centerXZ.z)
aspectRatio = 1.0
if not BigWorld.isVideoWindowed():
aspectRatio = BigWorld.getFullScreenAspectRatio()
else:
aspectRatio = BigWorld.screenWidth() / BigWorld.screenHeight()
camPos.y = max(halfSizesXZ.x / math.sin(0.5 * camFov * aspectRatio),
halfSizesXZ.y / math.sin(0.5 * camFov))
camMatr = Math.Matrix()
camMatr.setRotateYPR(Math.Vector3(0.0, math.pi * 0.5, 0.0))
camMatr.translation = camPos
camMatr.invert()
self.__cam = BigWorld.FreeCamera()
self.__cam.set(camMatr)
BigWorld.camera(self.__cam)
BigWorld.wg_enableSuperShot(True, False)
self.__savedWatchers = {}
for name in self.__watcherNames:
try:
self.__savedWatchers[name] = BigWorld.getWatcher(name)
if name.startswith('Visibility'):
BigWorld.setWatcher(name, False)
except TypeError:
LOG_WARNING('Failed to get/set watcher', name)
BigWorld.setWatcher('Client Settings/std fog/enabled', False)
BigWorld.projection().fov = camFov
BigWorld.setWatcher('Render/Fov', camFov)
BigWorld.setWatcher('Render/Near Plane', max(0.1, camPos.y - 1000.0))
BigWorld.setWatcher('Render/Far Plane', camPos.y + 1000.0)
BigWorld.setWatcher('Render/Objects Far Plane/Enabled', False)
BigWorld.setWatcher('Render/Shadows/qualityPreset', 7)
BigWorld.setWatcher('Client Settings/Script tick', False)
LOG_DEBUG('Vertical screenshot camera is enabled')
def enable(self, doEnable):
if self.__isEnabled == doEnable:
return
from cameras import FovExtended
if not doEnable:
self.__isEnabled = False
BigWorld.camera(self.__savedCamera)
BigWorld.wg_enableSuperShot(False, False)
for k, v in self.__savedWatchers.iteritems():
BigWorld.setWatcher(k, v)
FovExtended.instance().enabled = True
LOG_DEBUG('Vertical screenshot camera is disabled')
return
self.__isEnabled = True
self.__savedCamera = BigWorld.camera()
FovExtended.instance().enabled = False
arenaBB = BigWorld.wg_getSpaceBounds()
centerXZ = Math.Vector2(0.5 * (arenaBB[0] + arenaBB[2]), 0.5 * (arenaBB[1] + arenaBB[3]))
halfSizesXZ = Math.Vector2(0.5 * (arenaBB[2] - arenaBB[0]), 0.5 * (arenaBB[3] - arenaBB[1]))
camFov = math.radians(15.0)
camPos = Math.Vector3(centerXZ.x, 0, centerXZ.z)
aspectRatio = 1.0
if not BigWorld.isVideoWindowed():
aspectRatio = BigWorld.getFullScreenAspectRatio()
else:
aspectRatio = BigWorld.screenWidth() / BigWorld.screenHeight()
camPos.y = max(halfSizesXZ.x / math.sin(0.5 * camFov * aspectRatio), halfSizesXZ.y / math.sin(0.5 * camFov))
camMatr = Math.Matrix()
camMatr.setRotateYPR(Math.Vector3(0.0, math.pi * 0.5, 0.0))
camMatr.translation = camPos
camMatr.invert()
self.__cam = BigWorld.FreeCamera()
self.__cam.set(camMatr)
BigWorld.camera(self.__cam)
BigWorld.wg_enableSuperShot(True, False)
self.__savedWatchers = {}
for name in self.__watcherNames:
try:
self.__savedWatchers[name] = BigWorld.getWatcher(name)
if name.startswith('Visibility'):
BigWorld.setWatcher(name, False)
except TypeError:
LOG_WARNING('Failed to get/set watcher', name)
BigWorld.setWatcher('Client Settings/std fog/enabled', False)
BigWorld.projection().fov = camFov
BigWorld.setWatcher('Render/Fov', camFov)
BigWorld.setWatcher('Render/Near Plane', max(0.1, camPos.y - 1000.0))
BigWorld.setWatcher('Render/Far Plane', camPos.y + 1000.0)
BigWorld.setWatcher('Render/Objects Far Plane/Enabled', False)
BigWorld.setWatcher('Render/Shadows/qualityPreset', 7)
BigWorld.setWatcher('Client Settings/Script tick', False)
LOG_DEBUG('Vertical screenshot camera is enabled')
def _getValue(name, setting, force=False):
if name == _BOOTCAMP_MINIMAP_SIZE_SETTINGS_KEY and setting == KEY_SETTINGS:
fds = AccountSettings._readSection(
AccountSettings._readUserSection(), setting)
if not fds.has_key(name):
value = 2 if BigWorld.screenWidth(
) < BootcampAccountSettings.__SCREEN_WIDTH and BigWorld.screenHeight(
) < BootcampAccountSettings.__SCREEN_HEIGHT else 3
fds.write(name, base64.b64encode(pickle.dumps(value)))
return value
return AccountSettings._getValue(name, setting, force)
def getScopeRadius(self, direction):
dirNorm = direction.getNormalized(
) * self._context.targetLockShootDistance
if dirNorm.angle(Vector3(0, 1, 0)):
axis = dirNorm.cross(Vector3(0, 1, 0)).getNormalized()
else:
axis = dirNorm.cross(Vector3(1, 0, 0)).getNormalized()
dirNorm += axis * dirNorm.length * math.tan(
self._context.turretControlAimConeAngle
) + self._context.basePosition
res = BigWorld.worldToScreen(dirNorm) - Vector3(
0.5 * BigWorld.screenWidth(), 0.5 * BigWorld.screenHeight(), 1)
return res.length
def handleMouseEvent(self, comp, event):
width = float(BigWorld.screenWidth())
height = float(BigWorld.screenHeight())
if self.isDragging:
self.scrollTo(event.cursorPosition[0] + self.cursorDragOffset[0], event.cursorPosition[1] + self.cursorDragOffset[1])
elif event.dz != 0:
amt = 1.0 + event.dz / 1000.0
w, h = self.component.size
if not BigWorld.isKeyDown(Keys.KEY_LCONTROL):
self.component.size = (w * amt, h * amt)
else:
self.component.size = (w * amt, h)
self.calcScrollBounds()
return True
def handleMouseEvent(self, comp, event):
width = float(BigWorld.screenWidth())
height = float(BigWorld.screenHeight())
if self.isDragging:
self.scrollTo(event.cursorPosition[0] + self.cursorDragOffset[0],
event.cursorPosition[1] + self.cursorDragOffset[1])
elif event.dz != 0:
amt = 1.0 + event.dz / 1000.0
w, h = self.component.size
if not BigWorld.isKeyDown(Keys.KEY_LCONTROL):
self.component.size = (w * amt, h * amt)
else:
self.component.size = (w * amt, h)
self.calcScrollBounds()
return True
def __updateCursorPosition(self):
player = BigWorld.player()
reductionPointVector = getReductionPointVector(player.weaponsSettings)
direction = self._cameraStrategy.cursorDirection
if self._backRevert < 0:
p = player.getRotation().getAxisZ()
angle = p.angle(direction)
p *= -1
axis = p.cross(direction)
self._Q.fromAngleAxis(angle, axis)
direction = self._Q.rotateVec(p)
worldPos = direction * reductionPointVector.length * HUD_REDUCTION_POINT_SCALE + player.position
screenPoint = BigWorld.worldToScreen(worldPos)
screenPoint = Math.Vector3(
clamp(0.0, screenPoint.x, BigWorld.screenWidth()),
clamp(0.0, screenPoint.y, BigWorld.screenHeight()), 1.0)
self.mousePosition()
def show(self):
player = BigWorld.player()
target = BigWorld.target()
self.__targetID = target.id if target is not None else None
screenWidth = BigWorld.screenWidth()
screenHeight = BigWorld.screenHeight()
guiScreenWidth, guiScreenHeight = GUI.screenResolution()
ratioWidth = float(guiScreenWidth / screenWidth)
ratioHeight = float(guiScreenHeight / screenHeight)
ratio = (ratioWidth, ratioHeight)
crosshairType = self.__getCrosshairType(player, target)
ctrl = g_sessionProvider.shared.crosshair
if ctrl is not None:
position = ctrl.getPosition()
else:
position = (guiScreenWidth >> 1, guiScreenHeight >> 1)
self.as_showS(crosshairType, position, ratio)
return
def show(self):
player = BigWorld.player()
target = BigWorld.target()
self.__targetID = target.id if target is not None else None
screenWidth = BigWorld.screenWidth()
screenHeight = BigWorld.screenHeight()
guiScreenWidth, guiScreenHeight = GUI.screenResolution()
ratioWidth = float(guiScreenWidth / screenWidth)
ratioHeight = float(guiScreenHeight / screenHeight)
ratio = (ratioWidth, ratioHeight)
crosshairType = self.__getCrosshairType(player, target)
ctrl = g_sessionProvider.shared.crosshair
if ctrl is not None:
position = ctrl.getPosition()
else:
position = (guiScreenWidth >> 1, guiScreenHeight >> 1)
self.as_showS(crosshairType, position, ratio)
return
def AvatarInputHandler_onControlModeChanged(self, eMode, **args):
global y, aimMode
if battle.isBattleTypeSupported:
oldAimMMode = aimMode
if self._AvatarInputHandler__isArenaStarted:
if eMode == CTRL_MODE_NAME.ARCADE:
y = -BigWorld.screenHeight() * SHIFT
aimMode = ARCADE_MODE
elif eMode in [CTRL_MODE_NAME.SNIPER, CTRL_MODE_NAME.DUAL_GUN]:
y = 0.0
aimMode = SNIPER_MODE
elif eMode in [CTRL_MODE_NAME.ARTY, CTRL_MODE_NAME.STRATEGIC]:
y = 0.0
aimMode = STRATEGIC_MODE
else:
aimMode = None
else:
aimMode = ARCADE_MODE
if oldAimMMode != aimMode:
as_event('ON_AIM_MODE')
def getDamageAngle(authorID):
import gui.HUDconsts as hudConst
author = BigWorld.entities.get(authorID)
if author:
screenPos = BigWorld.worldToScreen(author.position)
screenCenterPos = Math.Vector3(BigWorld.screenWidth() / 2,
BigWorld.screenHeight() / 2, 0)
deltaPos = screenPos - screenCenterPos
side = deltaPos.z
deltaPos.z = 0
deltaPos.normalise()
pos = deltaPos * hudConst.CIRCLE_HUD_DAMAGE_DIRECTION_R
if side < 0:
pos *= -1
angle = math.atan2(
pos.x, pos.y
) - hudConst.CIRCLE_HUD_DAMAGE_DIRECTION_PICTURE_ROTATION + math.pi
angle = 2 * math.pi - angle
return angle
return 0
def show(self):
player = BigWorld.player()
target = BigWorld.target()
self.__targetID = target.id if target is not None else None
screenWidth = BigWorld.screenWidth()
screenHeight = BigWorld.screenHeight()
guiScreenWidth, guiScreenHeight = GUI.screenResolution()
ratioWidth = float(guiScreenWidth / screenWidth)
ratioHeight = float(guiScreenHeight / screenHeight)
ratio = (ratioWidth, ratioHeight)
crosshairType = self.__getCrosshairType(player, target)
ctrl = self.sessionProvider.shared.crosshair
if ctrl is not None:
position = ctrl.getDisaredPosition()
else:
position = (guiScreenWidth * 0.5, guiScreenHeight * 0.5)
if self.app is not None:
self.app.registerGuiKeyHandler(self)
self.as_showS(crosshairType, position, ratio)
return
def updateSize(self, fov, size):
self.__valuesQueue[self.__valuesQueueIndex] = size
self.__valuesQueueIndex = (self.__valuesQueueIndex + 1) % 10
newValue = sum(self.__valuesQueue) / 10
if newValue != 0:
newValue += self.__minTargetSize
deltaValue = newValue - self.__prevValue
if newValue != self.__targetValue:
self.__targetValue = newValue
self.__smoothStep = deltaValue / 10
if self.__prevValue != newValue or self.__prevFov != fov or self.__prevActive != self.__active:
if abs(deltaValue) > 0.0001:
newValue = self.__prevValue + self.__smoothStep
self.__prevValue = newValue
self.__prevFov = fov
self.__prevActive = self.__active
if GameEnvironment.g_instance:
value = clamp(self.__clampMinTargetSize,
TARGET_DISP_IDENTITY_CFC * newValue,
self.__clampMaxTargetSize)
GameEnvironment.g_instance.eOnCrossSizeChanged(
value / fov * 2.0 * BigWorld.screenHeight())
def _updateScroll(self):
self.component.scroll.y = -self.scrollIndex * (
self._lineHeight / (BigWorld.screenHeight() * 0.5))
def _recalcMaxScroll(self):
totalPixelHeight = self._lineHeight * self._displayedLineCount
self.component.minScroll.y = -totalPixelHeight / (
BigWorld.screenHeight() * 0.5)
def xvm_screenVCenter():
return BigWorld.screenHeight() // 2
def xvm_screenHeight():
return BigWorld.screenHeight()
def xvm_YFromBottom(y=0):
screenHeight = BigWorld.screenHeight()
try:
return screenHeight - float(y)
except ValueError:
return screenHeight
def InterfaceScaleSetting_setSystemValue(self, value):
if battle.isBattleTypeSupported:
global y
y = -BigWorld.screenHeight() * SHIFT if aimMode == ARCADE_MODE else 0.0
as_event('ON_AIM_MODE')
def Vehicle_onEnterWorld(self, prereqs):
global y, aimMode
if battle.isBattleTypeSupported:
y = -BigWorld.screenHeight() * SHIFT
aimMode = ARCADE_MODE
as_event('ON_AIM_MODE')
def xvm_screenVCenter():
return BigWorld.screenHeight() // 2
def xvm_screenHeight():
return BigWorld.screenHeight()
def _recalcMaxScroll(self):
totalPixelHeight = self._lineHeight * self._displayedLineCount
self.component.minScroll.y = -totalPixelHeight / (BigWorld.screenHeight() * 0.5)
def _updateScroll(self):
self.component.scroll.y = -self.scrollIndex * (self._lineHeight / (BigWorld.screenHeight() * 0.5))
