def updateSquad(self, squadID, squadInfo): """ Temporary method for receiving detailed info about our squad (regardless of whether a voice channel exists). @param squadID: unique squad ID (used only for further communication with Game Server) @param squadInfo: dictionary with 'accountIDs' and 'ownerID' keys """ if 'accountIDs' in squadInfo: self.__squadID = squadID self.__squadMembers = [int(id) for id in squadInfo['accountIDs']] self.__squadOwnerDbID = int(squadInfo['ownerID']) LOG_TRACE('VOIP updateSquad: squad ID {0}, owner {1}'.format( self.__squadID, self.__squadOwnerDbID)) self.__channelsMgr.updateChannel(consts.VOIP.CHANNEL_TYPES.SQUAD, self.__squadMembers, self.__squadOwnerDbID) for dbid in self.__squadMembers: self.__channelsMgr.refreshMemberState(dbid) else: LOG_TRACE('VOIP updateSquad: no squad') self.__squadID = None self.__squadMembers = [] self.__squadOwnerDbID = None return
def initialize(self, tsIdentities, muteList): if self.__initialized: LOG_ERROR('Already initialized!') return elif tsIdentities is None or muteList is None: return else: self.__tsIdentities = tsIdentities self.__muteList = set(muteList) LOG_TRACE('Initialized with TS3 identities: {0}'.format( self.__tsIdentities)) LOG_TRACE('Initialized with mute list: {0}'.format( self.__muteList)) numChannelTypes = len(self.__tsIdentities) LOG_DEBUG('verify') verify(numChannelTypes == consts.VOIP.CHANNEL_TYPES.QUANTITY) args = {ENGINE_PROTOCOL.KEY_PLAYER_DATABASE_ID: str(self.playerID)} numSupportedChannels = 0 for type in xrange(numChannelTypes): if self.__tsIdentities[type]: args[ ENGINE_PROTOCOL.KEY_CHANNEL_TYPE_INDEXED % numSupportedChannels] = consts.VOIP.CHANNEL_TYPES.getConstNameByValue( type) args[ENGINE_PROTOCOL.KEY_TS_IDENTITY_INDEXED % numSupportedChannels] = self.__tsIdentities[type] numSupportedChannels += 1 args[ENGINE_PROTOCOL.KEY_NUM_CHANNEL_TYPES] = str( numSupportedChannels) self.__initArgs = args if self.__enabled: self.__initializeInternal() return
def __onReceiveInitData(self, operation, returnCode, tsIdentities, muteList): """ Callback for receiving initialization data for client's VOIP module from Game Server. @param operation: not used @param returnCode: not used @param tsIdentities: list of TeamSpeak identities for specific channel types (consts.VOIP_CHANNEL_TYPES) @param muteList: list of database IDs of players in our personal mute list """ if self.__channelsMgr.initialized: LOG_WARNING( 'VOIP __onReceiveInitData: already initialized, ignoring') return g_xmppChatHandler.receiveMuteList([str(id) for id in muteList]) self.__voipSupported = False self.__arenaChannelSupported = False for id in tsIdentities: if id: self.__voipSupported = True self.__arenaChannelSupported = bool( tsIdentities[consts.VOIP.CHANNEL_TYPES.ARENA]) break LOG_TRACE('VOIP __onReceiveInitData: voice chat %s' % ('SUPPORTED' if self.__voipSupported else 'NOT SUPPORTED')) LOG_TRACE( 'VOIP __onReceiveInitData: arena channel %s' % ('SUPPORTED' if self.__arenaChannelSupported else 'NOT SUPPORTED')) self.__channelsMgr.initialize(tsIdentities, muteList) self.__applyCaptureDevice() self.__refreshVolume() for callback in self.__muteListRequests: callback(self.__channelsMgr.muteList) self.__muteListRequests = []
def runXmppChatCore(self, spaID, token): self.params['spaID'] = spaID chatConfig = Settings.g_instance.scriptConfig.xmppChatConfig connections = [] testPortStr = chatConfig.get('useTestPort') if testPortStr: LOG_TRACE("Xmpp chat: using test port for connection... '%s'" % testPortStr) try: testPort = int(testPortStr) for conn in self.params['xmpp_connections']: connections.append((conn[0], testPort)) except: LOG_TRACE("Xmpp chat: can not use test port '%s'" % testPortStr) if connections == []: connections = self.params['xmpp_connections'] BigWorld.XMPPChat.startClient(self.params['xmpp_host'], str(spaID), str(token), self.params['xmpp_std_rooms_svc'], self.params['xmpp_user_rooms_svc'], self.params['xmpp_specific_rooms_svc'], self.params['xmpp_clan_rooms_svc'], connections, self.params['xmpp_resource'], Settings.g_instance.clusterID, chatConfig) self.onUpdateChatSettings()
def __initializeInternal(self): VoipEngine.initialise(self.__initArgs) self.__initialized = True self.__initArgs = {} LOG_TRACE('Calling deferred actions...') for action in self.__deferredActions: action() self.__deferredActions = [] LOG_TRACE('Deferred actions finished.')
def onServerMessage(self, msg, args): if msg == consts.VOIP.SERVER_MESSAGES.CHAT_CREDENTIALS: LOG_TRACE('VOIP channel %s (%s) - received credentials' % (self.typeName, self.stateName)) self.__voipServiceDown = False self._provisioningKey = args['key'] self._securityHash = args['hash'] self.processEvent(_FSM_EVENTS.CREDENTIALS_RECEIVED) elif msg == consts.VOIP.SERVER_MESSAGES.CHAT_UNAVAILABLE: LOG_TRACE('VOIP channel %s (%s) - service is down! ceasing reconnect attempts until further notice' % (self.typeName, self.stateName)) self.__voipServiceDown = True self.processEvent(_FSM_EVENTS.SERVICE_UNAVAILABLE)
def refreshMemberState(self, dbid): channels = dict() talkingToChannel = None for channelType in xrange(consts.VOIP.CHANNEL_TYPES.QUANTITY): stateInChannel = self.__channels[channelType].getMemberState(dbid) if stateInChannel != MEMBER_STATES.UNKNOWN: channels[ channelType] = stateInChannel > MEMBER_STATES.DISCONNECTED if talkingToChannel is None and stateInChannel == MEMBER_STATES.TALKING: talkingToChannel = channelType LOG_TRACE( 'refreshMemberState: db ID %d, channels %r, talking to channel %s, active channel %s' % (dbid, channels, consts.VOIP.CHANNEL_TYPES.getConstNameByValue(talkingToChannel), consts.VOIP.CHANNEL_TYPES.getConstNameByValue( self.__activeChannel))) serviceError = False if self.enabled: if self.__activeChannel is not None and self.__channels[ self.__activeChannel].serviceError: serviceError = True elif any((channel.serviceError for channel in self.__channels)): serviceError = True if serviceError and dbid == self.playerID: iconID = VOIP_ICON_TYPES.UNAVAILABLE else: iconID = VOIP_ICON_TYPES.NONE if not serviceError and self.connectedAnywhere: if self.muteList is not None and dbid in self.muteList: iconID = VOIP_ICON_TYPES.MUTED elif talkingToChannel == consts.VOIP.CHANNEL_TYPES.ARENA: iconID = VOIP_ICON_TYPES.ARENA_CHANNEL_TALKING elif talkingToChannel == consts.VOIP.CHANNEL_TYPES.SQUAD: iconID = VOIP_ICON_TYPES.SQUAD_CHANNEL_TALKING elif talkingToChannel == consts.VOIP.CHANNEL_TYPES.SQUADRON: iconID = VOIP_ICON_TYPES.SQUAD_CHANNEL_TALKING elif dbid == self.playerID and talkingToChannel is None: if self.__activeChannel == consts.VOIP.CHANNEL_TYPES.ARENA: iconID = VOIP_ICON_TYPES.ARENA_CHANNEL elif self.__activeChannel == consts.VOIP.CHANNEL_TYPES.SQUAD: iconID = VOIP_ICON_TYPES.SQUAD_CHANNEL elif self.__activeChannel == consts.VOIP.CHANNEL_TYPES.SQUADRON: iconID = VOIP_ICON_TYPES.SQUAD_CHANNEL else: iconID = VOIP_ICON_TYPES.LISTENING elif dbid != self.playerID and self.__activeChannel is not None and self.__activeChannel in channels and not channels[ self.__activeChannel]: iconID = VOIP_ICON_TYPES.DISCONNECTED LOG_TRACE('refreshMemberState: icon %s' % VOIP_ICON_TYPES.getConstNameByValue(iconID)) self.eventMemberStateChanged(dbid, iconID) return
def processMessage(self, message, data): LOG_TRACE('VOIP channel %s (%s) processMessage: %s' % (self.typeName, self.stateName, ENGINE_PROTOCOL.MESSAGES.getConstNameByValue(message))) if message == ENGINE_PROTOCOL.MESSAGES.vmLoggedIn: self.processEvent(_FSM_EVENTS.SERVICE_CONNECTED) self.__members[self.__mgr.playerID] = MEMBER_STATES.CONNECTED self.__onMembersChanged() for dbid in self.__mgr.muteList: self.applyMemberMuteFlag(dbid, True) self.__mgr.refreshVoiceTransmission() elif message == ENGINE_PROTOCOL.MESSAGES.vmLoginFailed: self.processEvent(_FSM_EVENTS.SERVICE_ERROR, error=int(data[ENGINE_PROTOCOL.KEY_STATUS_CODE])) elif message == ENGINE_PROTOCOL.MESSAGES.vmLoggedOut: self.processEvent(_FSM_EVENTS.SERVICE_DISCONNECTED, error=int(data[ENGINE_PROTOCOL.KEY_STATUS_CODE])) for dbid in self.__members: self.__members[dbid] = MEMBER_STATES.DISCONNECTED self.__onMembersChanged() self.__mgr.refreshVoiceTransmission() elif message == ENGINE_PROTOCOL.MESSAGES.vmClientTalkingStatus: clientID = int(data[ENGINE_PROTOCOL.KEY_PLAYER_DATABASE_ID]) talking = data[ENGINE_PROTOCOL.KEY_STATE] == 'True' LOG_TRACE('client %d %s' % (clientID, 'TALKING' if talking else 'SILENT')) if clientID in self.__members: if talking: if self.__members[clientID] != MEMBER_STATES.DISCONNECTED: self.__members[clientID] = MEMBER_STATES.TALKING else: LOG_ERROR('client talking while not connected!') elif self.__members[clientID] == MEMBER_STATES.TALKING: self.__members[clientID] = MEMBER_STATES.CONNECTED self.__onMembersChanged(clientID) elif talking: LOG_ERROR('unknown client!') elif message == ENGINE_PROTOCOL.MESSAGES.vmClientMoved: clientID = int(data[ENGINE_PROTOCOL.KEY_PLAYER_DATABASE_ID]) LOG_DEBUG('verify') verify(clientID != self.__mgr.playerID) joined = data[ENGINE_PROTOCOL.KEY_TS_CHANNEL_ID] != '0' LOG_TRACE('client %d %s' % (clientID, 'JOINED' if joined else 'LEAVING')) if clientID in self.__members: if joined: if self.__members[clientID] == MEMBER_STATES.DISCONNECTED: self.__members[clientID] = MEMBER_STATES.CONNECTED muted = clientID in self.__mgr.muteList LOG_TRACE('re-applying mute status (%s) for joined client' % muted) self.applyMemberMuteFlag(clientID, muted) else: self.__members[clientID] = MEMBER_STATES.DISCONNECTED self.__onMembersChanged(clientID) elif joined: LOG_ERROR('unknown client joined!')
def __loadHangarSpace(self, hangarConfig, overrideSpace = None): LOG_TRACE('_HangarSpace::__loadHangarSpace', self.__space.spaceLoading(), self.__isVechicleLoading) if self.__inLoading(): LOG_TRACE('_HangarSpace::__loadHangarSpace(hangarConfig=' + str(hangarConfig) + ') - is delayed until space load is done') self.__delayedSpaceData = (hangarConfig, overrideSpace) else: camTargetShifted = False if self.__spaceLoaded: camTargetShifted = self.__space.hangarCamera.getStateObject().targetShifted self.__spaceLoaded = False self.__space.destroy() waitingID = Waiting.show(HANGAR_LOBBY_WAITING_SCREEN_MESSAGE, WaitingFlags.WORLD_DRAW_DISABLE | WaitingFlags.LOADING_FPS_MODE) self.__hangarConfig = hangarConfig self.__space.create(hangarConfig, partial(self.__spaceDone, waitingID), overrideSpace=overrideSpace) self.__space.hangarCamera.getStateObject().setCameraTargetShift(camTargetShifted)
def setPushToTalk(self, channelType, status, force=False): """ Activate or deactivate microphone for talking to a specific channel. Even when the microphone is active, actual voice transmission only occurs if its volume exceeds the "voice activation level" setting. @param channelType: Channel we want to talk to (member of consts.VOIP_CHANNEL_TYPES). If push-to-talk is active for several different channels at the same time, only one of them is chosen (e.g. arena has higher priority than squad). Push-to-talk changes are ignored in the following cases: - channel is not available or not connected; - channel is explicitly disabled by player; - VOIP module is currently in local test mode. All of these cases can be overridden by force argument. @param status: True to activate, False to deactivate talking to this channel. @param force: True to change status regardless of channel availability and connection status. This must be used for real "push-to-talk" behavior (in battle) when the corresponding hot key must be held, as opposed to toggle-button behavior in lobby. """ if status == self.__channelsMgr.getChannelPushToTalkStatus( channelType): return else: LOG_TRACE( 'VOIP setPushToTalk %s (force %s): channel %s' % (status, force, consts.VOIP.CHANNEL_TYPES.getConstNameByValue(channelType))) if self.__testMode and not force: LOG_WARNING('VOIP setPushToTalk ignored in local test mode') elif channelType == consts.VOIP.CHANNEL_TYPES.SQUAD and self.__squadID is not None and status == True and not self.__channelsMgr.isChannelAvailable( consts.VOIP.CHANNEL_TYPES.SQUAD ) and self.__channelsMgr.enabled: LOG_TRACE( 'VOIP setPushToTalk: requesting squad channel creation on demand' ) self.setSquadChannelStatus(True) self.__channelsMgr.setPushToTalk(channelType, status, force) elif not status or force or self.__channelsMgr.canTalkToChannel( channelType): self.__channelsMgr.setPushToTalk(channelType, status, force) else: LOG_WARNING( 'VOIP setPushToTalk ignored for unavailable/unconnected channel' ) return
def getUpgradesList(self, callbacksList, planeID, reload3DModel): LOG_TRACE('getUpgradesList(planeID)', planeID) if self.__planeSelected is None and planeID is None: return else: aircraftID = planeID or self.__planeSelected.planeID upgradesList = self.inventory.getAircraftUpgradesData(aircraftID) installedWeapons = self.inventory.getSlotsConfiguration(aircraftID) slotsInfo = self.inventory.getAircraftInstalledWeaponsData(aircraftID) customPresetUpgrades = self.inventory.getCustomPreset(aircraftID) presetAvailableList = self.inventory.getAvailablePresets(aircraftID, True) installedPreset = self.inventory.getInstalledPreset(aircraftID) if planeID is not None: plane = self.getCarouselAirplane(planeID) if plane is None: plane = getLobbyAirplane(planeID) else: plane = self.__planeSelected if plane is None or plane.planeID not in self.inventory.aircraftsData: LOG_ERROR('getUpgradesList() error', plane is None, plane is not None and plane.planeID not in self.inventory.aircraftsData) return plane.modules = LobbyAirplaneModules(plane.planeID, upgradesList) plane.weapons = LobbyAirplaneWeapons(plane.planeID, upgradesList, installedWeapons) plane.weapons.updateSlotsInfo(slotsInfo) plane.presets = LobbyAirplanePresets(plane.planeID, plane.modules, plane.weapons, customPresetUpgrades, presetAvailableList, installedPreset) plane.presets.fillPresets() plane.partTypes = plane.modules.getPartTypes() if planeID is None: if reload3DModel: self.queryRefresh3DModel(self.__planeSelected) self.sendUpgradesListToAS() for callback in callbacksList: callback() return
def onDestroyChannel(self, type): if not self.initialized: LOG_TRACE('NOT INITIALIZED - deferring onDestroyChannel()...') self.__deferredActions.append(lambda: self.onDestroyChannel(type)) return LOG_TRACE('onDestroyChannel: type {0}'.format( consts.VOIP.CHANNEL_TYPES.getConstNameByValue(type))) if not self.__tsIdentities[type]: LOG_ERROR('unsupported channel type - ignoring') return channel = self.__channels[type] if channel.available: channel.onDestroy() self.refreshVoiceTransmission() else: LOG_ERROR('channel does not exist!')
def enabled(self, enabled): if self.__enabled != enabled: LOG_TRACE('VOIP: enabled = %s' % enabled) self.__enabled = enabled self.eventEnabledFlagChanged(self.__enabled) for dbid in self.getAllKnownMembers(): self.refreshMemberState(dbid)
def visualizeMemberState(self, dbid, iconID, muted, observerType, observer): """ Request refresh of a member state (silent/talking/...) icon in GUI. @param dbid: database ID of a voice channel member @param iconID: state icon ID - member of clientconsts.VOIP_ICON_TYPES @param muted: is member currently in our mute list (may be used for context menus and such) @param observerType: member of consts.VOIP.MEMBER_STATUS_OBSERVER_TYPES @param observer: data specific to observerType (see implementation) """ if observerType == consts.VOIP.MEMBER_STATUS_OBSERVER_TYPES.LOBBY_SQUAD_PANEL: from gui.WindowsManager import g_windowsManager if g_windowsManager.getLobbyUI() is not None: from gui.Scaleform.windows import CustomObject args = CustomObject() args.dbid = str(dbid) args.state = iconID g_windowsManager.getLobbyUI().call_1(observer, args) else: LOG_TRACE('no lobby!') elif observerType == consts.VOIP.MEMBER_STATUS_OBSERVER_TYPES.ARENA_HUD: if dbid in observer: avatarID = observer[dbid] else: LOG_ERROR('unknown dbid %d' % dbid) else: LOG_ERROR( 'visualizeMemberState - invalid observer type {0}'.format( observerType)) return
def __call__(self, message, data=None): """ Handler for messages from C++ part (BigWorld.VOIP) """ if data is None: data = {} if message != ENGINE_PROTOCOL.MESSAGES.vmTick: LOG_TRACE('__call__: {0} {1}'.format( ENGINE_PROTOCOL.MESSAGES.getConstNameByValue(message), data)) if ENGINE_PROTOCOL.KEY_CHANNEL_TYPE in data: for channel in self.__channels: if channel.typeName == data[ENGINE_PROTOCOL.KEY_CHANNEL_TYPE]: channel.processMessage(message, data) break else: LOG_ERROR('invalid channel type %s' % data[ENGINE_PROTOCOL.KEY_CHANNEL_TYPE]) elif message == ENGINE_PROTOCOL.MESSAGES.vmCaptureDevices: numDevices = int(data[ENGINE_PROTOCOL.KEY_COUNT]) devices = [ str(data[ENGINE_PROTOCOL.KEY_CAPTURE_DEVICE_INDEXED % i]) for i in xrange(numDevices) ] currentDevice = str( data[ENGINE_PROTOCOL.KEY_CURRENT_CAPTURE_DEVICE]) self.eventCaptureDevicesUpdated(devices, currentDevice) elif message == ENGINE_PROTOCOL.MESSAGES.vmTick: self.eventTick() else: LOG_ERROR('unrecognized non-channel-specific message') return
def __syncAircraftsData(self, aircraftID, onSyncedCallback, sendASCallbacks = True): if aircraftID < 0: self.queryRefresh3DModel(None) return else: carouselAirplane = self.getCarouselAirplane(aircraftID) if self.__lobby is not None: if carouselAirplane: airplane = self.inventory.getCarouselAircraft(aircraftID) self.__updateCarouselAirplane(carouselAirplane, airplane) if self.inventory.isAircraftBought(aircraftID): if carouselAirplane.blockType & BLOCK_TYPE.IN_BATTLE: GameSound().ui.onPlaneBlocked(aircraftID) elif carouselAirplane.blockType == BLOCK_TYPE.UNLOCKED: GameSound().ui.onPlaneUnlocked(aircraftID) if sendASCallbacks: self.__lobby.call_1('hangar.updateCarouselSlot', aircraftID, carouselAirplane.getCarouselAirplaneObject()) else: self.inventory.addAircrafttoBoughtList(aircraftID) if sendASCallbacks: LOG_TRACE('Added new plane to carousel: planeID {0}'.format(carouselAirplane.planeID)) self.__lobby.call_1('hangar.addPlaneCarousel', carouselAirplane.getCarouselAirplaneObject(), self.airplanesCount()) self.__lobby.call_1('hangar.setSelectedAircraftID', aircraftID) self.queryRefresh3DModel(carouselAirplane) SyncOperationKeeper.stop(FLAGS_CODE.BUY_PLANE) if self.__lobby.mode == HANGAR_MODE.RESEARCH: if self.__lobby.researchTreeHelper.enteredInAircraftID: pass else: self.__lobby.researchTreeHelper.reloadCurrentBranch() if onSyncedCallback is not None: onSyncedCallback(aircraftID) if self.__lobby is not None and self.__lobby.mode == HANGAR_MODE.AMMUNITION: self.updateSpecs() return
def Init(): global g_instance LOG_TRACE('Init()') if g_instance == None: g_instance = CameraEffectManager() g_instance.init() return g_instance
def __updateCarouselAirplane(self, carouselAirplane, airplane, force = False): if carouselAirplane is None: LOG_ERROR('Airplane not found', airplane['plane']) return elif airplane is None: return else: LOG_TRACE('__updateCarouselAirplane() setting block type {0} for {1}'.format(airplane['blockType'], carouselAirplane.planeID)) from Account import PLANE_BLOCK_TYPE PLANE_BLOCK_TYPE[carouselAirplane.planeID] = airplane['blockType'] carouselAirplane.blockType = airplane['blockType'] carouselAirplane.repairCost = airplane['repairCost'] carouselAirplane.experience = airplane['planeXP'] carouselAirplane.isPrimary = airplane['isPrimary'] carouselAirplane.autoRepair = airplane['autoRepair'] carouselAirplane.autoRefill = airplane['autoRefill'] if carouselAirplane.weapons is not None: carouselAirplane.weapons.setInstalledWeapons(airplane['weaponsSlot']) if carouselAirplane.modules is not None: carouselAirplane.modules.setInstalledModules(airplane['modules']) carouselAirplane.sellPrice = airplane['sellPrice'] carouselAirplane.isPremium = airplane['isPremium'] carouselAirplane.isElite = airplane['isElite'] if not carouselAirplane.extraExperience and airplane['dailyFirstWinXPFactor'] or force: carouselAirplane.extraExperience = airplane['dailyFirstWinXPFactor'] if not carouselAirplane.extraRemains and airplane['dailyFirstWinRemains'] or force: carouselAirplane.extraRemains = airplane['dailyFirstWinRemains'] carouselAirplane.isBought = True return
def setMainEntity(self, entity): """set main matrix for all camera states from entity""" LOG_TRACE('Camera.setMainEntity', entity.id) self.__setContext(CameraContext(entity)) self.__cancelZoomCallback() self.__context.entity.setModelVisible(not ( self.curZoomData.hideModel if self.curZoomData else False))
def setSquadronChannelStatus(self, channelEnabled): """ Request to create or delete current squadron's voice channel (affects all squadron members). Channel creation is allowed for any member of the squadron, but only squadron leader can delete the channel. @param channelEnabled: True to request creation of squadron channel, False to request deletion """ if self.__channelsMgr.isChannelSupported( consts.VOIP.CHANNEL_TYPES.SQUADRON): if self.__squadronID is not None: if channelEnabled or self.__squadronOwnerDbID == self.__channelsMgr.playerID: LOG_TRACE( 'VOIP setSquadronChannelStatus: squadron %s, status %s' % (self.__squadronID, channelEnabled)) self.__channelsMgr.outbox.sendSquadronChannelStatus( self.__squadronID, channelEnabled) else: LOG_ERROR( 'VOIP setSquadronChannelStatus: only leader can delete the channel!' ) else: LOG_ERROR( 'VOIP setSquadronChannelStatus: not a squadron member!') else: LOG_ERROR( 'VOIP setSquadronChannelStatus: channel not supported by server' ) return
def onLeaveArenaChannel(self): """ Must be called when our arena voice channel is destroyed by Game Server (or when this player is no longer allowed inside the channel). We must leave it (if not kicked already) and cease any reconnection attempts. """ LOG_TRACE('VOIP onLeaveArenaChannel') self.__channelsMgr.onDestroyChannel(consts.VOIP.CHANNEL_TYPES.ARENA)
def onRoomCreateInitialized(self): LOG_DEBUG('onRoomCreateInitialized') self.__getAccountCmd().getTrainingCreateRoomFilters( self.__setCreateRoomFiltersResponse) LOG_TRACE('onRoomCreateInitialized() disabling battle button') self.__account.call_1('hangar.isInBattleEnabled', False) self.__roomCreateActive = True
def Destroy(): global g_instance LOG_TRACE('Destroy()') if g_instance != None: g_instance.destroy() g_instance = None return
def performInitialization(self): LOG_TRACE('WebBrowser: initializing...') areaID = connectionManager.areaID loginName = connectionManager.loginName if areaID is None or loginName is None: LOG_ERROR( 'WebBrowser: Unable to open browser: bad areaID or loginName in script_config.xml', areaID, loginName) return else: try: self.kongUrl = Settings.g_instance.scriptConfig.urls[ WebBrowser.URL_KONG] self.areaID = areaID self.userEncoded = base64.b64encode(loginName) self.shadow = BigWorld.WebBrowser() self.shadow.awesomium.script = self GlobalEvents.onKeyEvent += self.handleKeyEvent GlobalEvents.onMouseEvent.insert(0, self.handleMouseWheelEvent) BigWorld.player().tokenManager.requestToken( self.receiveDatabaseIDAndContinueInitialization) except: LOG_ERROR('WebBrowser: initialization failed') return
def __refreshFlags(): flags = WaitingFlags.NONE for messageinfo in Waiting.__waitingDict.itervalues(): flags |= messageinfo.flags LOG_TRACE('Current waiting flags: {0}'.format( Waiting.__printableFlags(flags))) Waiting.__setFlags(flags)
def updateChannel(self, type, members, leader): if not self.initialized: LOG_TRACE('NOT INITIALIZED - deferring updateChannel()...') self.__deferredActions.append( lambda: self.updateChannel(type, members, leader)) return LOG_TRACE('updateChannel: type %s, members: %r, leader: %r' % (consts.VOIP.CHANNEL_TYPES.getConstNameByValue(type), members, leader)) if not self.__tsIdentities[type]: LOG_ERROR('unsupported channel type - ignoring') return channel = self.__channels[type] if channel.available: channel.setMembers(members, leader) else: LOG_ERROR('channel not registered!')
def syncClanChatChannel(self): import BWPersonality LOG_TRACE('Xmpp chat: try to sync chat channel for clan: ', BWPersonality.g_initPlayerInfo.clanDBID) if int(BWPersonality.g_initPlayerInfo.clanDBID) > 0: GameServerMessenger.g_instance.syncClanChatChannel( self.__onSyncClanChatChannel) else: self.__onSyncClanChatChannel(0, 1)
def syncServData(self): LOG_TRACE('syncServData') if self.inventory is None: waitingSyncID = Waiting.show('LOBBY_LOAD_HANGAR_SPACE_VEHICLE', WaitingFlags.WORLD_DRAW_DISABLE) from InventoryClient import InventoryClient self.inventory = InventoryClient(BigWorld.player().accountCmd, partial(self.onFinishSyncServData, waitingSyncID)) self.inventory.setOpSender(BigWorld.player().accountCmd) BigWorld.player().syncActionList() return
def onLeaveArenaScreen(self): """ Must be called when user leaves the arena screen. Connection to the arena channel can only be active when in arena screen, regardless of the status of the channel itself and any user settings. """ LOG_TRACE('VOIP onLeaveArenaScreen') self.__inArenaScreen = False self.__channelsMgr.setChannelEnabled(consts.VOIP.CHANNEL_TYPES.ARENA, False)
def receiveDatabaseIDAndContinueInitialization(self, databaseID, token): self.databaseID = databaseID self.kongUrl = self.kongUrl % { 'userEncoded': self.userEncoded, 'areaID': self.areaID, 'databaseID': self.databaseID } self.shadow.awesomium.loadURL(self.kongUrl) LOG_TRACE('WebBrowser: initialized.')