class UnitsListRequester(IPrbListRequester):
"""
Class for units list requester. It has basic pagination functionality,
and could store items found in local cache.
"""
itemsCache = dependency.descriptor(IItemsCache)
def __init__(self):
self.__selectedID = None
self.__callback = None
self.__callbackUpdate = None
self.__isSubscribed = False
self.__cooldown = PrbCooldownManager()
self.__handlers = {}
self.__cache = {}
return
def __del__(self):
LOG_DEBUG('Units list requester deleted:', self)
def start(self, callback):
self.__cache.clear()
if callback is not None and callable(callback):
self.__callback = callback
else:
LOG_ERROR('Callback is None or is not callable')
return
if self.__cooldown.isInProcess(REQUEST_TYPE.UNITS_LIST):
self.__cooldown.fireEvent(REQUEST_TYPE.UNITS_LIST)
browser = prb_getters.getClientUnitBrowser()
if browser:
self.__unitBrowser_onUnitsListReceived(browser.results)
return
def stop(self):
self.__cache.clear()
self.__callback = None
self.__callbackUpdate = None
return
def request(self, **kwargs):
if self.__cooldown.validate(REQUEST_TYPE.UNITS_LIST):
return
LOG_DEBUG('Request list of units', kwargs)
self.__cooldown.process(REQUEST_TYPE.UNITS_LIST)
self.__cache.clear()
browser = prb_getters.getClientUnitBrowser()
if browser:
if 'req' in kwargs:
req = kwargs['req']
if req in self.__handlers:
if self.__handlers[req](browser, **kwargs):
Waiting.show('prebattle/auto_search')
else:
LOG_ERROR('Request is not supported', kwargs)
else:
LOG_ERROR('Request is not found', self.__handlers.keys(),
kwargs)
else:
LOG_ERROR('Unit browser is not defined')
def subscribe(self, unitTypeFlags):
"""
Subscribes to client unit browser events
Args:
unitTypeFlags: flags of units visibility
"""
if self.__isSubscribed:
return
self.__isSubscribed = True
browser = prb_getters.getClientUnitBrowser()
if browser:
self.__cooldown.process(REQUEST_TYPE.UNITS_LIST)
self.__handlers = {
REQUEST_TYPE.UNITS_RECENTER: self.__recenter,
REQUEST_TYPE.UNITS_REFRESH: self.__refresh,
REQUEST_TYPE.UNITS_NAV_LEFT: self.__navLeft,
REQUEST_TYPE.UNITS_NAV_RIGHT: self.__navRight
}
browser.subscribe(unitTypeFlags=unitTypeFlags)
browser.onResultsReceived += self.__unitBrowser_onUnitsListReceived
browser.onResultsUpdated += self.__unitBrowser_onUnitsListUpdated
else:
LOG_ERROR('Unit browser is not defined')
def unsubscribe(self):
"""
Unsubscribes to client unit browser events
"""
self.__handlers.clear()
browser = prb_getters.getClientUnitBrowser()
if browser:
if self.__isSubscribed:
browser.unsubscribe()
browser.onResultsReceived -= self.__unitBrowser_onUnitsListReceived
browser.onResultsUpdated -= self.__unitBrowser_onUnitsListUpdated
self.__isSubscribed = False
self.__selectedID = None
return
def setSelectedID(self, selectedID):
"""
Sets currently selected item ID
Args:
selectedID: selected unit ID
"""
self.__selectedID = selectedID
def addCacheItem(self, item):
"""
Adds item to local cache.
Args:
item: unit item data
"""
self.__cache[item.cfdUnitID] = item
def getCacheItem(self, cfdUnitID):
"""
Tries to get item from local cache.
Args:
cfdUnitID: unit index
"""
try:
item = self.__cache[cfdUnitID]
except KeyError:
LOG_ERROR('Item not found in cache', cfdUnitID)
item = None
return item
def removeCacheItem(self, cfdUnitID):
"""
Removes item from local cache.
Args:
cfdUnitID: unit index
"""
self.__cache.pop(cfdUnitID, None)
return
def __navLeft(self, browser, **kwargs):
"""
Loads next bunch of units
Args:
browser: unit browser instance
"""
browser.left()
return True
def __navRight(self, browser, **kwargs):
"""
Loads previous bunch of units
Args:
browser: unit browser instance
"""
browser.right()
return True
def __recenter(self, browser, **kwargs):
"""
Resets current page to default
Args:
browser: unit browser instance
"""
result = False
if 'unitTypeFlags' in kwargs:
browser.recenter(self.itemsCache.items.stats.globalRating,
unitTypeFlags=kwargs['unitTypeFlags'])
result = True
else:
LOG_ERROR('Types of units are not defined', kwargs)
return result
def __refresh(self, browser, **kwargs):
"""
Refreshes currently selected page
Args:
browser: unit browser instance
"""
browser.refresh()
return True
def __unitBrowser_onUnitsListReceived(self, data):
"""
Listener for list receive event
Args:
data: result with units data, like unit Idx -> unit data
"""
Waiting.hide('prebattle/auto_search')
if self.__callback:
self.__callback(
self.__selectedID, True,
self.__cooldown.isInProcess(REQUEST_TYPE.UNITS_LIST),
UnitsListIterator(self, data))
def __unitBrowser_onUnitsListUpdated(self, data):
"""
Listener for list update event
Args:
data: result with units data, like unit Idx -> unit data
"""
if self.__callback:
self.__callback(self.__selectedID, False, False,
UnitsUpdateIterator(self, data))
def __init__(self, modeFlags, settings, permClass=None, limits=None, requestHandlers=None):
super(LegacyEntity, self).__init__(FUNCTIONAL_FLAG.LEGACY, modeFlags, ILegacyListener, requestHandlers)
self._settings = settings
self._permClass = permClass or LegacyPermissions
self._limits = limits or LegacyLimits(self)
self._cooldown = PrbCooldownManager()
class LegacyEntity(_LegacyEntity):
def __init__(self, modeFlags, settings, permClass=None, limits=None, requestHandlers=None):
super(LegacyEntity, self).__init__(FUNCTIONAL_FLAG.LEGACY, modeFlags, ILegacyListener, requestHandlers)
self._settings = settings
self._permClass = permClass or LegacyPermissions
self._limits = limits or LegacyLimits(self)
self._cooldown = PrbCooldownManager()
def init(self, clientPrb=None, ctx=None):
if clientPrb is None:
clientPrb = prb_getters.getClientPrebattle()
if clientPrb is not None:
clientPrb.onSettingUpdated += self.prb_onSettingUpdated
clientPrb.onRosterReceived += self.prb_onRosterReceived
clientPrb.onTeamStatesReceived += self.prb_onTeamStatesReceived
clientPrb.onPlayerStateChanged += self.prb_onPlayerStateChanged
clientPrb.onPlayerRosterChanged += self.prb_onPlayerRosterChanged
clientPrb.onPlayerAdded += self.prb_onPlayerAdded
clientPrb.onPlayerRemoved += self.prb_onPlayerRemoved
clientPrb.onKickedFromQueue += self.prb_onKickedFromQueue
else:
LOG_ERROR('ClientPrebattle is not defined')
return super(LegacyEntity, self).init(clientPrb, ctx)
def fini(self, clientPrb=None, ctx=None, woEvents=False):
self._settings = None
result = super(LegacyEntity, self).fini(clientPrb, ctx=ctx, woEvents=woEvents)
if self._limits is not None:
self._limits.clear()
self._limits = None
self.clear()
if clientPrb is None:
clientPrb = prb_getters.getClientPrebattle()
if clientPrb is not None:
clientPrb.onSettingUpdated -= self.prb_onSettingUpdated
clientPrb.onTeamStatesReceived -= self.prb_onTeamStatesReceived
clientPrb.onPlayerStateChanged -= self.prb_onPlayerStateChanged
clientPrb.onPlayerRosterChanged -= self.prb_onPlayerRosterChanged
clientPrb.onPlayerAdded -= self.prb_onPlayerAdded
clientPrb.onPlayerRemoved -= self.prb_onPlayerRemoved
clientPrb.onKickedFromQueue -= self.prb_onKickedFromQueue
return result
def isPlayerJoined(self, ctx):
return ctx.getCtrlType() is CTRL_ENTITY_TYPE.LEGACY and ctx.getEntityType() == self.getEntityType() and ctx.getID() == self.getID() and ctx.getBonusType() == self.getBonusType()
def getID(self):
return prb_getters.getPrebattleID()
def getEntityType(self):
return self._settings['type'] if self._settings else 0
def getBonusType(self):
return self._settings['bonusType'] if self._settings else 0
def getSettings(self):
return self._settings
def getLimits(self):
return self._limits
def getPermissions(self, pID=None):
clazz = self._permClass
rosterKey = self.getRosterKey(pID=pID)
if rosterKey is not None:
team, _ = decodeRoster(rosterKey)
pInfo = self.getPlayerInfo(pID=pID, rosterKey=rosterKey)
if pInfo is not None:
return clazz(roles=self.getRoles(pDatabaseID=pInfo.dbID, clanDBID=pInfo.clanDBID, team=team), pState=pInfo.state, teamState=self.getTeamState(team=team), hasLockedState=self.hasLockedState())
return clazz()
def isCommander(self, pDatabaseID=None):
return self._permClass.isCreator(self.getRoles(pDatabaseID=pDatabaseID))
def hasLockedState(self):
if g_playerEvents.isPlayerEntityChanging:
return True
_, assigned = decodeRoster(self.getRosterKey())
return self.getTeamState().isInQueue() and self.getPlayerInfo().isReady() and assigned
def getConfirmDialogMeta(self, ctx):
if not self._settings or ctx.isForced():
return None
else:
prbType = self.getEntityType()
if self.hasLockedState():
meta = rally_dialog_meta.RallyLeaveDisabledDialogMeta(CTRL_ENTITY_TYPE.LEGACY, prbType)
else:
meta = rally_dialog_meta.createPrbLeaveMeta(ctx, prbType, self.canSwitch(ctx))
return meta
def getRosterKey(self, pID=None):
rosters = prb_getters.getPrebattleRosters()
rosterRange = PREBATTLE_ROSTER.getRange(self.getEntityType())
if pID is None:
pID = account_helpers.getPlayerID()
for roster in rosterRange:
if roster in rosters and pID in rosters[roster].keys():
return roster
return PREBATTLE_ROSTER.UNKNOWN
def getPlayerInfo(self, pID=None, rosterKey=None):
rosters = prb_getters.getPrebattleRosters()
if pID is None:
pID = account_helpers.getPlayerID()
if rosterKey is not None:
if rosterKey in rosters and pID in rosters[rosterKey].keys():
return prb_items.PlayerPrbInfo(pID, entity=self, roster=rosterKey, **rosters[rosterKey][pID])
else:
rosterRange = PREBATTLE_ROSTER.getRange(self.getEntityType())
for roster in rosterRange:
if roster in rosters and pID in rosters[roster].keys():
return prb_items.PlayerPrbInfo(pID, entity=self, roster=roster, **rosters[roster][pID])
return prb_items.PlayerPrbInfo(-1L)
def getPlayerInfoByDbID(self, dbID):
rosters = prb_getters.getPrebattleRosters()
rosterRange = PREBATTLE_ROSTER.getRange(self.getEntityType())
for roster in rosterRange:
if roster in rosters:
for pID, data in rosters[roster].iteritems():
if data['dbID'] == dbID:
return prb_items.PlayerPrbInfo(pID, entity=self, roster=roster, **rosters[roster][pID])
return prb_items.PlayerPrbInfo(-1L)
def getPlayerTeam(self, pID=None):
team = 0
roster = self.getRosterKey(pID=pID)
if roster is not PREBATTLE_ROSTER.UNKNOWN:
team, _ = decodeRoster(roster)
return team
def getTeamState(self, team=None):
result = prb_items.TeamStateInfo(0)
if team is None:
roster = self.getRosterKey()
if roster is not PREBATTLE_ROSTER.UNKNOWN:
team, _ = decodeRoster(self.getRosterKey())
teamStates = prb_getters.getPrebattleTeamStates()
if team is not None and team < len(teamStates):
result = prb_items.TeamStateInfo(teamStates[team])
return result
def getRoles(self, pDatabaseID=None, clanDBID=None, team=None):
result = 0
if self._settings is None:
return result
else:
if pDatabaseID is None:
pDatabaseID = account_helpers.getAccountDatabaseID()
roles = self._settings['roles']
if pDatabaseID in roles:
result = roles[pDatabaseID]
if not result and clanDBID:
roles = self._settings['clanRoles']
if clanDBID in roles:
result = roles[clanDBID]
if not result and team:
roles = self._settings['teamRoles']
if team in roles:
result = roles[team]
return result
def getProps(self):
return prb_items.PrbPropsInfo(**prb_getters.getPrebattleProps())
def leave(self, ctx, callback=None):
ctx.startProcessing(callback)
BigWorld.player().prb_leave(lambda *args: None)
def resetPlayerState(self):
def setNotReady(code):
if code >= 0:
BigWorld.player().prb_notReady(PREBATTLE_ACCOUNT_STATE.NOT_READY, lambda *args: None)
if self.isCommander() and self.getTeamState().isInQueue():
BigWorld.player().prb_teamNotReady(self.getPlayerTeam(), setNotReady)
elif self.getPlayerInfo().isReady():
if self.getTeamState().isInQueue():
self._deferredReset = True
else:
setNotReady(0)
def assign(self, ctx, callback=None):
prevTeam, _ = decodeRoster(self.getRosterKey(pID=ctx.getPlayerID()))
nextTeam, assigned = decodeRoster(ctx.getRoster())
pPermissions = self.getPermissions()
if prevTeam is nextTeam:
if not pPermissions.canAssignToTeam(team=nextTeam):
LOG_ERROR('Player can not change roster', nextTeam, assigned)
if callback:
callback(False)
return
elif not pPermissions.canChangePlayerTeam():
LOG_ERROR('Player can not change team', prevTeam, nextTeam)
if callback:
callback(False)
return
result = self.getLimits().isMaxCountValid(nextTeam, assigned)
if result is not None and not result.isValid:
LOG_ERROR('Max count limit', nextTeam, assigned)
ctx.setErrorString(PREBATTLE_ERRORS.ROSTER_LIMIT)
if callback:
callback(False)
return
else:
ctx.startProcessing(callback)
BigWorld.player().prb_assign(ctx.getPlayerID(), ctx.getRoster(), ctx.onResponseReceived)
return
def setTeamState(self, ctx, callback=None):
team = ctx.getTeam()
if not self.getPermissions().canSetTeamState(team=team):
LOG_ERROR('Player can not change state of team', team)
if callback:
callback(False)
return
teamState = self.getTeamState()
setReady = ctx.isReadyState()
if setReady and teamState.isNotReady():
if teamState.isLocked():
LOG_ERROR('Team is locked')
if callback:
callback(False)
else:
self._setTeamReady(ctx, callback=callback)
elif not setReady and teamState.isInQueue():
self._setTeamNotReady(ctx, callback=callback)
elif callback:
callback(True)
def setPlayerState(self, ctx, callback=None):
playerInfo = self.getPlayerInfo()
if playerInfo is not None:
playerIsReady = playerInfo.isReady()
setReady = ctx.isReadyState()
if setReady and not playerIsReady:
self._setPlayerReady(ctx, callback=callback)
elif not setReady and playerIsReady:
self._setPlayerNotReady(ctx, callback=callback)
elif callback:
callback(True)
else:
LOG_ERROR('Account info not found in prebattle.rosters', ctx)
if callback:
callback(False)
return
def kickPlayer(self, ctx, callback=None):
pID = ctx.getPlayerID()
rosterKey = self.getRosterKey(pID=pID)
team, assigned = decodeRoster(rosterKey)
pPermissions = self.getPermissions()
if not pPermissions.canKick(team=team):
LOG_ERROR('Player can not kick from team', team, pPermissions)
if callback:
callback(False)
return
if assigned and self.getPlayerInfo(pID=pID, rosterKey=rosterKey).isReady():
if self.getTeamState(team=team).isInQueue():
LOG_ERROR('Player is ready, assigned and team is ready or locked', ctx)
if callback:
callback(False)
return
ctx.startProcessing(callback)
BigWorld.player().prb_kick(ctx.getPlayerID(), ctx.onResponseReceived)
def swapTeams(self, ctx, callback=None):
if self._cooldown.validate(REQUEST_TYPE.SWAP_TEAMS):
if callback:
callback(False)
return
pPermissions = self.getPermissions()
if pPermissions.canChangePlayerTeam():
ctx.startProcessing(callback)
BigWorld.player().prb_swapTeams(ctx.onResponseReceived)
self._cooldown.process(REQUEST_TYPE.SWAP_TEAMS)
else:
LOG_ERROR('Player can not swap teams', pPermissions)
if callback:
callback(False)
def sendInvites(self, ctx, callback=None):
if self._cooldown.validate(REQUEST_TYPE.SEND_INVITE):
if callback:
callback(False)
return
pPermissions = self.getPermissions()
if pPermissions.canSendInvite():
BigWorld.player().prb_sendInvites(ctx.getDatabaseIDs(), ctx.getComment())
self._cooldown.process(REQUEST_TYPE.SEND_INVITE, coolDown=REQUEST_COOLDOWN.PREBATTLE_INVITES)
if callback:
callback(True)
else:
LOG_ERROR('Player can not send invite', pPermissions)
if callback:
callback(False)
def prb_onSettingUpdated(self, settingName):
settingValue = self._settings[settingName]
LOG_DEBUG('prb_onSettingUpdated', settingName, settingValue)
self._invokeListeners('onSettingUpdated', self, settingName, settingValue)
def prb_onTeamStatesReceived(self):
team1State = self.getTeamState(team=1)
team2State = self.getTeamState(team=2)
LOG_DEBUG('prb_onTeamStatesReceived', team1State, team2State)
if self._deferredReset and not self.getTeamState().isInQueue():
self._deferredReset = False
self.resetPlayerState()
self._invokeListeners('onTeamStatesReceived', self, team1State, team2State)
def prb_onPlayerStateChanged(self, pID, roster):
accountInfo = self.getPlayerInfo(pID=pID)
LOG_DEBUG('prb_onPlayerStateChanged', accountInfo)
self._invokeListeners('onPlayerStateChanged', self, roster, accountInfo)
def prb_onRosterReceived(self):
LOG_DEBUG('prb_onRosterReceived')
rosters = self.getRosters()
self._invokeListeners('onRostersChanged', self, rosters, True)
team = self.getPlayerTeam()
self._invokeListeners('onPlayerTeamNumberChanged', self, team)
def prb_onPlayerRosterChanged(self, pID, prevRoster, roster, actorID):
LOG_DEBUG('prb_onPlayerRosterChanged', pID, prevRoster, roster, actorID)
rosters = self.getRosters(keys=[prevRoster, roster])
actorInfo = self.getPlayerInfo(pID=actorID)
playerInfo = self.getPlayerInfo(pID=pID)
for listener in self.getListenersIterator():
if actorInfo and playerInfo:
listener.onPlayerRosterChanged(self, actorInfo, playerInfo)
listener.onRostersChanged(self, rosters, False)
if pID == account_helpers.getPlayerID():
prevTeam, _ = decodeRoster(prevRoster)
currentTeam, _ = decodeRoster(roster)
if currentTeam is not prevTeam:
self._invokeListeners('onPlayerTeamNumberChanged', self, currentTeam)
def prb_onPlayerAdded(self, pID, roster):
LOG_DEBUG('prb_onPlayerAdded', pID, roster)
rosters = self.getRosters(keys=[roster])
playerInfo = self.getPlayerInfo(pID=pID, rosterKey=roster)
for listener in self.getListenersIterator():
listener.onPlayerAdded(self, playerInfo)
listener.onRostersChanged(self, rosters, False)
def prb_onPlayerRemoved(self, pID, roster, name):
LOG_DEBUG('prb_onPlayerRemoved', pID, roster, name)
rosters = self.getRosters(keys=[roster])
playerInfo = prb_items.PlayerPrbInfo(pID, name=name)
for listener in self.getListenersIterator():
listener.onPlayerRemoved(self, playerInfo)
listener.onRostersChanged(self, rosters, False)
def prb_onKickedFromQueue(self):
LOG_DEBUG('prb_onKickedFromQueue')
message = messages.getPrbKickedFromQueueMessage(prb_getters.getPrebattleTypeName(self.getEntityType()))
if message:
SystemMessages.pushMessage(message, type=SystemMessages.SM_TYPE.Warning)
def _createActionsValidator(self):
return LegacyActionsValidator(self)
def _setTeamReady(self, ctx, callback=None):
if prb_getters.isParentControlActivated():
g_eventDispatcher.showParentControlNotification()
if callback:
callback(False)
return
else:
result = self._limits.isTeamValid()
def _requestResponse(code, errStr):
msg = messages.getInvalidTeamServerMessage(errStr, entity=self)
if msg is not None:
SystemMessages.pushMessage(msg, type=SystemMessages.SM_TYPE.Error)
ctx.onResponseReceived(code)
return
if result is None or result.isValid:
ctx.startProcessing(callback)
BigWorld.player().prb_teamReady(ctx.getTeam(), ctx.isForced(), ctx.getGamePlayMask(), _requestResponse)
else:
notValidReason = result.restriction
LOG_ERROR('Team is invalid', notValidReason)
if callback:
callback(False)
SystemMessages.pushMessage(messages.getInvalidTeamMessage(notValidReason, entity=self), type=SystemMessages.SM_TYPE.Error)
return
def _setTeamNotReady(self, ctx, callback=None):
if self._cooldown.validate(REQUEST_TYPE.SET_TEAM_STATE):
if callback:
callback(False)
return
ctx.startProcessing(callback)
BigWorld.player().prb_teamNotReady(ctx.getTeam(), ctx.onResponseReceived)
self._cooldown.process(REQUEST_TYPE.SET_TEAM_STATE, coolDown=REQUEST_COOLDOWN.PREBATTLE_TEAM_NOT_READY)
def _setPlayerNotReady(self, ctx, callback=None):
if self._cooldown.validate(REQUEST_TYPE.SET_PLAYER_STATE, REQUEST_COOLDOWN.PREBATTLE_NOT_READY):
if callback:
callback(False)
return
rosterKey = self.getRosterKey()
team, assigned = decodeRoster(rosterKey)
if assigned and self.getTeamState(team=team).isInQueue():
LOG_ERROR('Account assigned and team is ready or locked')
if callback:
callback(False)
return
ctx.startProcessing(callback)
BigWorld.player().prb_notReady(PREBATTLE_ACCOUNT_STATE.NOT_READY, ctx.onResponseReceived)
self._cooldown.process(REQUEST_TYPE.SET_PLAYER_STATE, coolDown=REQUEST_COOLDOWN.PREBATTLE_NOT_READY)
def _setPlayerReady(self, ctx, callback=None):
if prb_getters.isParentControlActivated():
g_eventDispatcher.showParentControlNotification()
if callback:
callback(False)
return
if ctx.doVehicleValidation():
result = self._limits.isVehicleValid()
if not self._processValidationResult(ctx, result):
if callback:
callback(False)
return
rosterKey = self.getRosterKey()
team, assigned = decodeRoster(rosterKey)
if assigned and self.getTeamState(team=team).isInQueue():
LOG_ERROR('Account assigned and team is ready or locked')
if callback:
callback(False)
return
ctx.startProcessing(callback)
BigWorld.player().prb_ready(ctx.getVehicleInventoryID(), ctx.onResponseReceived)
def _processValidationResult(self, ctx, result):
if result is not None and not result.isValid:
if not (ctx.isInitial() and result.restriction == PREBATTLE_RESTRICTION.VEHICLE_NOT_READY):
SystemMessages.pushMessage(messages.getInvalidVehicleMessage(result.restriction, self), type=SystemMessages.SM_TYPE.Error)
return False
else:
return True
def _getPlayersStateStats(self, rosterKey):
clientPrb = prb_getters.getClientPrebattle()
notReadyCount = 0
playersCount = 0
limitMaxCount = 0
haveInBattle = False
if clientPrb:
players = clientPrb.rosters.get(rosterKey, {})
playersCount = len(players)
team, assigned = decodeRoster(rosterKey)
teamLimits = self._settings.getTeamLimits(team)
limitMaxCount = teamLimits['maxCount'][not assigned]
for _, accInfo in players.iteritems():
state = accInfo.get('state', PREBATTLE_ACCOUNT_STATE.UNKNOWN)
if not state & PREBATTLE_ACCOUNT_STATE.READY:
notReadyCount += 1
if not haveInBattle and state & PREBATTLE_ACCOUNT_STATE.IN_BATTLE:
haveInBattle = True
return prb_items.PlayersStateStats(notReadyCount, haveInBattle, playersCount, limitMaxCount)
class UnitsListRequester(IPrbListRequester):
itemsCache = dependency.descriptor(IItemsCache)
def __init__(self):
self.__selectedID = None
self.__callback = None
self.__callbackUpdate = None
self.__isSubscribed = False
self.__cooldown = PrbCooldownManager()
self.__handlers = {}
self.__cache = {}
return
def __del__(self):
LOG_DEBUG('Units list requester deleted:', self)
def start(self, callback):
self.__cache.clear()
if callback is not None and callable(callback):
self.__callback = callback
else:
LOG_ERROR('Callback is None or is not callable')
return
if self.__cooldown.isInProcess(REQUEST_TYPE.UNITS_LIST):
self.__cooldown.fireEvent(REQUEST_TYPE.UNITS_LIST)
browser = prb_getters.getClientUnitBrowser()
if browser:
self.__unitBrowser_onUnitsListReceived(browser.results)
return
def stop(self):
self.__cache.clear()
self.__callback = None
self.__callbackUpdate = None
return
def request(self, **kwargs):
if self.__cooldown.validate(REQUEST_TYPE.UNITS_LIST):
return
LOG_DEBUG('Request list of units', kwargs)
self.__cooldown.process(REQUEST_TYPE.UNITS_LIST)
self.__cache.clear()
browser = prb_getters.getClientUnitBrowser()
if browser:
if 'req' in kwargs:
req = kwargs['req']
if req in self.__handlers:
if self.__handlers[req](browser, **kwargs):
Waiting.show('prebattle/auto_search')
else:
LOG_ERROR('Request is not supported', kwargs)
else:
LOG_ERROR('Request is not found', self.__handlers.keys(),
kwargs)
else:
LOG_ERROR('Unit browser is not defined')
def subscribe(self, unitTypeFlags):
if self.__isSubscribed:
return
self.__isSubscribed = True
browser = prb_getters.getClientUnitBrowser()
if browser:
self.__cooldown.process(REQUEST_TYPE.UNITS_LIST)
self.__handlers = {
REQUEST_TYPE.UNITS_RECENTER: self.__recenter,
REQUEST_TYPE.UNITS_REFRESH: self.__refresh,
REQUEST_TYPE.UNITS_NAV_LEFT: self.__navLeft,
REQUEST_TYPE.UNITS_NAV_RIGHT: self.__navRight
}
browser.subscribe(unitTypeFlags=unitTypeFlags)
browser.onResultsReceived += self.__unitBrowser_onUnitsListReceived
browser.onResultsUpdated += self.__unitBrowser_onUnitsListUpdated
else:
LOG_ERROR('Unit browser is not defined')
def unsubscribe(self):
self.__handlers.clear()
browser = prb_getters.getClientUnitBrowser()
if browser:
if self.__isSubscribed:
browser.unsubscribe()
browser.onResultsReceived -= self.__unitBrowser_onUnitsListReceived
browser.onResultsUpdated -= self.__unitBrowser_onUnitsListUpdated
self.__isSubscribed = False
self.__selectedID = None
return
def setSelectedID(self, selectedID):
self.__selectedID = selectedID
def addCacheItem(self, item):
self.__cache[item.cfdUnitID] = item
def getCacheItem(self, cfdUnitID):
try:
item = self.__cache[cfdUnitID]
except KeyError:
LOG_ERROR('Item not found in cache', cfdUnitID)
item = None
return item
def removeCacheItem(self, cfdUnitID):
self.__cache.pop(cfdUnitID, None)
return
def __navLeft(self, browser, **kwargs):
browser.left()
return True
def __navRight(self, browser, **kwargs):
browser.right()
return True
def __recenter(self, browser, **kwargs):
result = False
if 'unitTypeFlags' in kwargs:
browser.recenter(self.itemsCache.items.stats.globalRating,
unitTypeFlags=kwargs['unitTypeFlags'])
result = True
else:
LOG_ERROR('Types of units are not defined', kwargs)
return result
def __refresh(self, browser, **kwargs):
browser.refresh()
return True
def __unitBrowser_onUnitsListReceived(self, data):
Waiting.hide('prebattle/auto_search')
if self.__callback:
self.__callback(
self.__selectedID, True,
self.__cooldown.isInProcess(REQUEST_TYPE.UNITS_LIST),
UnitsListIterator(self, data))
def __unitBrowser_onUnitsListUpdated(self, data):
if self.__callback:
self.__callback(self.__selectedID, False, False,
UnitsUpdateIterator(self, data))
def __init__(self):
self.__callback = None
self.__ctx = None
self.__cooldown = PrbCooldownManager()
return
class CompanyListRequester(IPrbListRequester):
"""
Companies list request class
"""
def __init__(self):
self.__callback = None
self.__ctx = None
self.__cooldown = PrbCooldownManager()
return
def start(self, callback):
if callback is not None and callable(callback):
self.__callback = callback
else:
LOG_ERROR('Callback is None or is not callable')
return
g_playerEvents.onPrebattlesListReceived += self.__pe_onPrebattlesListReceived
return
def stop(self):
g_playerEvents.onPrebattlesListReceived -= self.__pe_onPrebattlesListReceived
self.__callback = None
if self.__ctx:
self.__ctx.stopProcessing(False)
self.__ctx = None
return
def request(self, ctx=None):
if self.__cooldown.validate(REQUEST_TYPE.PREBATTLES_LIST):
if ctx:
ctx.stopProcessing(False)
return
LOG_DEBUG('Request prebattle', ctx)
self.__cooldown.process(REQUEST_TYPE.PREBATTLES_LIST)
self.__ctx = ctx
if ctx.byDivision():
BigWorld.player().requestPrebattlesByDivision(
ctx.isNotInBattle, ctx.division)
elif ctx.byName():
BigWorld.player().requestPrebattlesByName(PREBATTLE_TYPE.COMPANY,
ctx.isNotInBattle,
ctx.creatorMask)
else:
BigWorld.player().requestPrebattles(
PREBATTLE_TYPE.COMPANY, PREBATTLE_CACHE_KEY.CREATE_TIME,
ctx.isNotInBattle, -50, 0)
def isInCooldown(self):
"""
Is this request in cooldown now
"""
return self.__cooldown.isInProcess(REQUEST_TYPE.PREBATTLES_LIST)
def getCooldown(self):
"""
Get cooldown time for companies list request
"""
return self.__cooldown.getTime(REQUEST_TYPE.PREBATTLES_LIST)
def fireCooldownEvent(self):
"""
Fires cooldown event to notify about operation
"""
self.__cooldown.fireEvent(
REQUEST_TYPE.PREBATTLES_LIST,
self.__cooldown.getTime(REQUEST_TYPE.PREBATTLES_LIST))
def __pe_onPrebattlesListReceived(self, prbType, count, prebattles):
"""
Listener for event of companies list receive
Args:
prbType: items prebattle type
count: items count
prebattles: items, which are list of (sort key, prebattle ID, prebattle cache data like
PREBATTLE_CACHE_KEY -> data
"""
if prbType != PREBATTLE_TYPE.COMPANY:
return
else:
if self.__ctx:
self.__ctx.stopProcessing(True)
self.__ctx = None
self.__callback(prb_seqs.PrbListIterator(reversed(prebattles)))
return