def __init__(self, data, position): super(_StaticObjectMarker3D, self).__init__() path = data.get('path') offset = data.get('offset', Math.Vector3(0, 0, 0)) self.__model = None if path is not None: try: self.__model = BigWorld.Model(path) self.__model.position = Math.Vector3(position[:]) + offset self.__model.castsShadow = False except ValueError: LOG_CURRENT_EXCEPTION() LOG_ERROR('Model not found', path) return except AttributeError: LOG_CURRENT_EXCEPTION() return BigWorld.addModel(self.__model) action = data.get('action') if action is not None and len(action): try: self.__model.action(action)() except ValueError: LOG_ERROR('Action not found', path, action) return
def _callbackWrapper(self, requestType, callback, cooldown, *args): callbackID = self._waiters.pop(requestType, None) if callbackID is not None: BigWorld.cancelCallback(callbackID) self._cooldown.adjust(requestType, cooldown) callback(*args) return
def __getControlQuestion(self, usingGold = False): if usingGold: currencyFormatter = BigWorld.wg_getGoldFormat(long(self.controlNumber)) else: currencyFormatter = BigWorld.wg_getIntegralFormat(long(self.controlNumber)) question = makeHtmlString('html_templates:lobby/dialogs', 'vehicleSellQuestion', {'controlNumber': currencyFormatter}) return question
def __setSoundMuted(self, isMuted): BigWorld.wg_setMovieSoundMuted(isMuted) SoundGroups.g_instance.enableAmbientAndMusic(isMuted) if isMuted: MusicController.g_musicController.play(MusicController.MUSIC_EVENT_LOBBY) else: MusicController.g_musicController.stop()
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 onLogoff(self, arg): import BigWorld def logOff(): g_appLoader.goToLoginByRQ() BigWorld.callback(0.1, logOff)
def __updateAim(self): if self.getPlaybackSpeedIdx() == 0: player = BigWorld.player() if isPlayerAvatar(): if player.inputHandler.aim is not None: player.inputHandler.aim._update() BigWorld.callback(0, self.__updateAim)
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 onLogin(self, user, password, host, hdlr, isSocialToken2Login = False): self.__onLoggingTryingEndHdlr = hdlr self.__kickedFromServer = False self.__kickPeripheryID = None if self.__closeCallbackId: BigWorld.cancelCallback(self.__closeCallbackId) self.__closeCallbackId = None if not isSocialToken2Login: if not self.__validateCredentials(user.lower().strip(), password.strip()): self.__onLoggingTryingEndHdlr() return Waiting.show('login') self.__loginDataLoader.host = host self.__loginDataLoader.user = user self.__loginDataLoader.passLength = len(password) self.__loginDataLoader.saveUserConfig(user, self.__loginDataLoader.host) password = pwd_token.generate(password) if len(self.__loginDataLoader.token2): password = '' token2 = self.__loginDataLoader.token2 if AUTO_LOGIN_QUERY_URL == host: g_preDefinedHosts.autoLoginQuery(lambda host: connectionManager.connect(getHostURL(host, token2), user, password, host.keyPath, nickName=None, token2=token2, isNeedSavingPwd=self.__loginDataLoader.rememberPwd)) return else: host = g_preDefinedHosts.byUrl(host) connectionManager.connect(getHostURL(host, token2, True), user, password, host.keyPath, nickName=None, token2=token2, isNeedSavingPwd=self.__loginDataLoader.rememberPwd) 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 __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 __onTick(self): self.__timerID = BigWorld.callback(self.__ROTATION_TICK_LENGTH, self.__onTick) lockEnabled = BigWorld.player().inputHandler.getAimingMode(AIMING_MODE.TARGET_LOCK) usePredictedLockShotPoint = lockEnabled and VehicleGunRotator.USE_LOCK_PREDICTION replayCtrl = BattleReplay.g_replayCtrl if not self.__clientMode and not replayCtrl.isPlaying and not usePredictedLockShotPoint: return else: replayCtrl = BattleReplay.g_replayCtrl if replayCtrl.isPlaying: shotPoint = replayCtrl.getGunRotatorTargetPoint() else: predictedLockShotPoint = self.predictLockedTargetShotPoint() if usePredictedLockShotPoint else None shotPoint = self.__shotPointSourceFunctor() if predictedLockShotPoint is None else predictedLockShotPoint if shotPoint is None and self.__targetLastShotPoint: shotPoint = self.__lastShotPoint if replayCtrl.isRecording: if shotPoint is not None: replayCtrl.setGunRotatorTargetPoint(shotPoint) self.__updateShotPointOnServer(shotPoint) timeDiff = self.__getTimeDiff() if timeDiff is None: return self.__time = BigWorld.time() self.__rotate(shotPoint, timeDiff) self.__updateGunMarker() if replayCtrl.isPlaying: replayCtrl.resetUpdateGunOnTimeWarp() return
def _clearWaiters(self): if self._waiters is not None: while len(self._waiters): _, callbackID = self._waiters.popitem() BigWorld.cancelCallback(callbackID) return
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 handleLoginRejectedBan(self, status, message): try: LOG_DEBUG('handleLoginRejectedBan', message) msg_dict = json.loads(message) if not isinstance(msg_dict, dict): self.handleLoginCustomDefinedError(status, message) return self.__loginDataLoader.token2 = msg_dict.get('token2', '') self.__loginDataLoader.saveUserToken(self.__loginDataLoader.passLength, self.__loginDataLoader.token2) json_dict = msg_dict.get('bans') msg_dict = json.loads(json_dict) except Exception: LOG_CURRENT_EXCEPTION() self.handleLoginCustomDefinedError(status, message) return expiryTime = 0 reason = '' if isinstance(msg_dict, dict): expiryTime = int(msg_dict.get('expiryTime', 0)) reason = i18n.encodeUtf8(msg_dict.get('reason', '')) if reason == BAN_REASON.CHINA_MIGRATION: self.__handleMigrationNeeded() if reason.startswith('#'): reason = i18n.makeString(reason) if expiryTime > 0: expiryTime = makeLocalServerTime(expiryTime) expiryTime = BigWorld.wg_getLongDateFormat(expiryTime) + ' ' + BigWorld.wg_getLongTimeFormat(expiryTime) errorMessage = i18n.makeString(MENU.LOGIN_STATUS_LOGIN_REJECTED_BAN, time=expiryTime, reason=reason) else: errorMessage = i18n.makeString(MENU.LOGIN_STATUS_LOGIN_REJECTED_BAN_UNLIMITED, reason=reason) self.onSetStatus(errorMessage, self.ALL_VALID)
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 _populate(self): super(BattleLoading, self)._populate() g_sessionProvider.addArenaCtrl(self) BigWorld.wg_updateColorGrading() BigWorld.wg_enableGUIBackground(True, False) self._addArenaTypeData() Waiting.close()
def handleKey(self, key, isDown, offset): cmdMap = CommandMapping.g_instance if cmdMap.isFired(CommandMapping.CMD_RADIAL_MENU_SHOW, key): if isDown: if self.__currentVehicleDesc is None: self.__currentVehicleDesc = self.__getCurrentVehicleDesc() if self.__currentVehicleDesc is not None: self.__currentTarget = BigWorld.target() mouseUsedForShow = getScaleformKey(key) <= BW_TO_SCALEFORM[Keys.KEY_MOUSE7] self.__onMenuShow(offset, mouseUsedForShow) else: self.__onMenuHide() elif isDown: if not self.__ingameMenuIsVisible(): if self.__currentVehicleDesc is None: self.__currentVehicleDesc = self.__getCurrentVehicleDesc() if not self.__showed: self.__currentTarget = BigWorld.target() for command in self.KEYB_MAPPINGS: shortcut = self.KEYB_CMDS_MAPPINGS[command] if cmdMap.isFired(getattr(CommandMapping, shortcut), key): action = self.__getMappedCommand(command) if action not in self.DENIED_KEYB_CMDS: self.onAction(action) return
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 _clearEntitiesAndSpaces(self): from gui.shared.utils.HangarSpace import g_hangarSpace keepClientOnlySpaces = False if g_hangarSpace is not None and g_hangarSpace.inited: keepClientOnlySpaces = g_hangarSpace.spaceLoading() BigWorld.clearEntitiesAndSpaces(keepClientOnlySpaces) return
def delayCallback(self, seconds, func, *args, **kwargs): curId = self.__callbacks.get(func) if curId is not None: BigWorld.cancelCallback(curId) del self.__callbacks[func] curId = BigWorld.callback(seconds, functools.partial(self.__funcWrapper, func, *args, **kwargs)) self.__callbacks[func] = curId
def _doAttention(self, index, duration): player = BigWorld.player() if player is not None and player.isTeleport: position = minimap_utils.getPositionByCellIndex(index, *self._boundingBox) result = BigWorld.collide(player.spaceID, (position[0], 1000.0, position[2]), (position[0], -1000.0, position[2])) player.base.vehicle_teleport((position[0], result[0][1], position[2]), 0) return
def create(self): if self.__flagEntity is not None: LOG_ERROR('Flags: Wrong usage of offline flags') return else: self.__entityID = BigWorld.createEntity('OfflineFlag', BigWorld.player().spaceID, 0, self.__position, Vector3(0.0, 0.0, 0.0), dict({'flagID': self.__flagID})) 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 showCursor(): """not scaleform specific. show the bigworld mouse cursor""" import GUI import BigWorld c = GUI.mcursor() c.visible = 1 BigWorld.setCursor(c)
def save(self): tmpList = [] for fireKey, listKeyInfo in self.__mapping.iteritems(): for command, satelliteKeys, isDefault in listKeyInfo: if isDefault: continue if len(satelliteKeys): continue commandName = self.getName(command) listSatelliteKeyNames = [] for key in satelliteKeys: listSatelliteKeyNames.append('KEY_' + BigWorld.keyToString(key)) strSatelliteKeyNames = '' for keyName in listSatelliteKeyNames: strSatelliteKeyNames += keyName + ' ' strSatelliteKeyNames = strSatelliteKeyNames.strip() fireKeyName = 'KEY_' + BigWorld.keyToString(fireKey) tmpList.append((commandName, fireKeyName, strSatelliteKeyNames)) if len(tmpList): section = Settings.g_instance.userPrefs section.deleteSection(CommandMapping.__USER_CONFIG_SECTION_NAME) section = section.createSection(CommandMapping.__USER_CONFIG_SECTION_NAME) for commandName, fireKeyName, strSatelliteKeynames in tmpList: subsec = section.createSection(commandName) subsec.writeString('fireKey', fireKeyName) subsec.writeString('satelliteKeys', strSatelliteKeyNames) Settings.g_instance.save()
def __doShot(self, data): data['_timerID'] = None try: vehicle = data['entity'] if not vehicle.isAlive(): self.stop(data) return burstCount, burstInterval = data['_burst'] gunModel = data['_gunModel'] effPlayer = data['_effectsListPlayer'] effPlayer.stop() if burstCount == 1: effPlayer.play(gunModel, None, partial(self.stop, data)) withShot = 1 else: data['_burst'] = (burstCount - 1, burstInterval) data['_timerID'] = BigWorld.callback(burstInterval, partial(self.__doShot, data)) effPlayer.play(gunModel) withShot = 2 if data['entity'].isPlayerVehicle: avatar = BigWorld.player() avatar.getOwnVehicleShotDispersionAngle(avatar.gunRotator.turretRotationSpeed, withShot) if not vehicle.appearance.isInWater: groundWaveEff = effPlayer.effectsList.relatedEffects.get('groundWave') if groundWaveEff is not None: self.__doGroundWaveEffect(data['entity'], groundWaveEff, gunModel) self.__doRecoil(vehicle, gunModel) if vehicle.isPlayerVehicle: appearance = vehicle.appearance appearance.executeShootingVibrations(vehicle.typeDescriptor.shot['shell']['caliber']) except Exception: LOG_CURRENT_EXCEPTION() self.stop(data) return
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 stop(self, finished = False, reason = TUTORIAL_STOP_REASON.DEFAULT): if self._tutorialStopped: return else: if self.__callbackID is not None: BigWorld.cancelCallback(self.__callbackID) self.__callbackID = None if self._funcScene is not None: self._funcScene.leave() if self._data is not None: self._data.clear() GlobalStorage.clearFlags() if self._sound is not None: self._sound.stop() self._sound = None if self._gui is not None: self._gui.fini(isItemsRevert=self._descriptor.isItemsRevertIfStop(reason)) self._gui = None if finished: self._cache.setFinished(True).write() else: self._cache.update(self._currentChapter, self._flags.getDict() if self._flags else None) self._cache = None g_tutorialWeaver.clear() clearTutorialProxy() self.removeEffectsInQueue() self._nextChapter = False self._tutorialStopped = True self._initialized = 0 return