def assign(self, ctx, callback = None):
"""
Sends request to assing player to some team.
Args:
ctx: assign context
callback: operation callback
"""
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 assign(self, ctx, callback=None):
pID = ctx.getPlayerID()
prevTeam, _ = decodeRoster(self.getRosterKey(pID=pID))
nextTeam, assigned = decodeRoster(ctx.getRoster())
pPermissions = self.getPermissions()
if prevTeam is nextTeam:
if not pPermissions.canAssignToTeam(team=nextTeam, isSelfAssignment=pID == account_helpers.getPlayerID()):
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 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
if prevTeam != nextTeam:
result = self.getLimits().isMaxCountValid(nextTeam, assigned)
if result is not None and not result.isValid:
LOG_ERROR('Max count limit', nextTeam, assigned)
if callback:
callback(False)
return
ctx.startProcessing(callback)
BigWorld.player().prb_assignGroup(ctx.getPlayerID(), ctx.getRoster(),
ctx.getGroup(),
ctx.onResponseReceived)
return
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 _validate(self):
if g_playerEvents.isPlayerEntityChanging:
return ValidationResult(False, PREBATTLE_RESTRICTION.TEAM_IS_IN_QUEUE)
_, assigned = decodeRoster(self._entity.getRosterKey())
if self._entity.getTeamState().isInQueue() and assigned:
return ValidationResult(False, PREBATTLE_RESTRICTION.TEAM_IS_IN_QUEUE)
return super(InQueueValidator, self)._validate()
def getPlayerAssignFlagChanged(actorInfo, playerInfo):
_, assigned = decodeRoster(playerInfo.roster)
if assigned:
key = '#system_messages:memberRosterChangedMain'
else:
key = '#system_messages:memberRosterChangedSecond'
return i18n.makeString(key, actorInfo.getFullName(), playerInfo.getFullName())
def getRosters(self, keys=None):
rosters = prb_getters.getPrebattleRosters()
if keys is None:
result = {
PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1: [],
PREBATTLE_ROSTER.ASSIGNED_IN_TEAM2: [],
PREBATTLE_ROSTER.UNASSIGNED: []
}
else:
result = {}
for key in keys:
if PREBATTLE_ROSTER.UNASSIGNED & key != 0:
result[PREBATTLE_ROSTER.UNASSIGNED] = []
result[key] = []
hasTeam1 = PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1 in result
hasTeam2 = PREBATTLE_ROSTER.ASSIGNED_IN_TEAM2 in result
hasUnassigned = PREBATTLE_ROSTER.UNASSIGNED in result
for key, roster in rosters.iteritems():
accounts = map(
lambda accInfo: prb_items.PlayerPrbInfo(
accInfo[0], entity=self, roster=key, **accInfo[1]),
roster.iteritems())
team, assigned = decodeRoster(key)
if assigned:
if hasTeam1 and team == 1:
result[PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1] = accounts
elif hasTeam2 and team == 2:
result[PREBATTLE_ROSTER.ASSIGNED_IN_TEAM2] = accounts
if hasUnassigned:
result[PREBATTLE_ROSTER.UNASSIGNED].extend(accounts)
return result
def _setPlayerReady(self, ctx, callback = None):
"""
Sets player state to ready.
Args:
ctx: set player state request context
callback: operation callback
"""
if prb_getters.isParentControlActivated():
g_eventDispatcher.showParentControlNotification()
if callback:
callback(False)
return
if g_currentVehicle.isObserver():
if not self._processValidationResult(ctx, ValidationResult(False, PREBATTLE_RESTRICTION.VEHICLE_NOT_SUPPORTED)):
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 kickPlayer(self, ctx, callback=None):
"""
Kicks player from team.
Args:
ctx: kick player request context
callback: operation callback
"""
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 onPlayerStateChanged(self, entity, roster, playerInfo):
team, assigned = decodeRoster(roster)
data = {'dbID': playerInfo.dbID,
'state': playerInfo.state,
'igrType': playerInfo.igrType,
'icon': '',
'vShortName': '',
'vLevel': '',
'vType': '',
'isCurrentPayer': playerInfo.isCurrentPlayer()}
if playerInfo.isVehicleSpecified():
moduleName = ''
vehicle = playerInfo.getVehicle()
badgeVisibility = playerInfo.getEnhancementVisibility()
if badgeVisibility:
moduleName = MODULE_NAME_SEPARATOR.join([ self.__craftmacineConrtoller.getModuleName(module) for module in playerInfo.getEnhancementModules() ])
data.update({'icon': vehicle.iconContour,
'vShortName': vehicle.shortUserName,
'vLevel': int2roman(vehicle.level),
'vType': vehicle.type,
'isExperimentalModule': bool(badgeVisibility),
'experimentalModuleName': moduleName})
self.as_setPlayerStateS(team, assigned, data)
if playerInfo.isCurrentPlayer():
self.as_toggleReadyBtnS(not playerInfo.isReady())
else:
chat = self.chat
if chat:
chat.as_addMessageS(messages.getPlayerStateChangedMessage(self.__prbName, playerInfo))
def onPlayerStateChanged(self, entity, roster, playerInfo):
team, assigned = decodeRoster(roster)
data = {
'dbID': playerInfo.dbID,
'state': playerInfo.state,
'igrType': playerInfo.igrType,
'icon': '',
'vShortName': '',
'vLevel': '',
'vType': ''
}
if playerInfo.isVehicleSpecified():
vehicle = playerInfo.getVehicle()
data.update({
'icon': vehicle.iconContour,
'vShortName': vehicle.shortUserName,
'vLevel': int2roman(vehicle.level),
'vType': vehicle.type
})
self.as_setPlayerStateS(team, assigned, data)
if playerInfo.isCurrentPlayer():
self.as_toggleReadyBtnS(not playerInfo.isReady())
else:
chat = self.chat
if chat:
chat.as_addMessageS(
messages.getPlayerStateChangedMessage(
self.__prbName, playerInfo))
def getRosters(self, keys = None):
rosters = getPrebattleRosters()
if keys is None:
result = {PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1: [],
PREBATTLE_ROSTER.ASSIGNED_IN_TEAM2: [],
PREBATTLE_ROSTER.UNASSIGNED: []}
else:
result = {}
for key in keys:
if PREBATTLE_ROSTER.UNASSIGNED & key != 0:
result[PREBATTLE_ROSTER.UNASSIGNED] = []
else:
result[key] = []
hasTeam1 = PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1 in result
hasTeam2 = PREBATTLE_ROSTER.ASSIGNED_IN_TEAM2 in result
hasUnassigned = PREBATTLE_ROSTER.UNASSIGNED in result
for (key, roster,) in rosters.iteritems():
accounts = map(lambda accInfo: prb_items.PlayerPrbInfo(accInfo[0], functional=self, roster=key, **accInfo[1]), roster.iteritems())
(team, assigned,) = decodeRoster(key)
if assigned:
if hasTeam1 and team is 1:
result[PREBATTLE_ROSTER.ASSIGNED_IN_TEAM1] = accounts
elif hasTeam2 and team is 2:
result[PREBATTLE_ROSTER.ASSIGNED_IN_TEAM2] = accounts
elif hasUnassigned:
result[PREBATTLE_ROSTER.UNASSIGNED].extend(accounts)
return result
def _getPlayersStateStats(self, rosterKey):
"""
Get players state stats
Args:
rosterKey: roster key mask
"""
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)
def _setPlayerReady(self, ctx, callback=None):
if prb_getters.isParentControlActivated():
g_eventDispatcher.showParentControlNotification()
if callback:
callback(False)
return
if ctx.doVehicleValidation():
isValid, notValidReason = self._limits.isVehicleValid()
if not isValid:
SystemMessages.pushMessage(messages.getInvalidVehicleMessage(
notValidReason, self),
type=SystemMessages.SM_TYPE.Error)
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 getPlayerAssignFlagChanged(actorInfo, playerInfo):
_, assigned = decodeRoster(playerInfo.roster)
if assigned:
key = '#system_messages:memberRosterChangedMain'
else:
key = '#system_messages:memberRosterChangedSecond'
return i18n.makeString(key, actorInfo.getFullName(),
playerInfo.getFullName())
def canPlayerDoAction(self):
isValid, notValidReason = True, ''
team, assigned = decodeRoster(self.getRosterKey())
if self.isCreator():
isValid, notValidReason = self._limits.isTeamValid()
elif self.getTeamState().isInQueue() and assigned:
isValid = False
return (isValid, notValidReason)
def canPlayerDoAction(self):
isValid, notValidReason = True, ''
team, assigned = decodeRoster(self.getRosterKey())
if self.getTeamState().isInQueue() and assigned:
isValid, notValidReason = False, PREBATTLE_RESTRICTION.TEAM_IS_IN_QUEUE
elif self.isCreator():
isValid, notValidReason = self._limits.isTeamValid()
return (isValid, notValidReason)
def canPlayerDoAction(self):
isValid, notValidReason = True, ''
team, assigned = decodeRoster(self.getRosterKey())
if self.isCreator():
isValid, notValidReason = self._limits.isTeamValid()
elif self.getTeamState().isInQueue() and assigned:
isValid = False
return (isValid, notValidReason)
def canPlayerDoAction(self):
isValid, notValidReason = True, ''
team, assigned = decodeRoster(self.getRosterKey())
if self.getTeamState().isInQueue() and assigned:
isValid, notValidReason = False, PREBATTLE_RESTRICTION.TEAM_IS_IN_QUEUE
elif self.isCreator():
isValid, notValidReason = self._limits.isTeamValid()
return (isValid, notValidReason)
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 createPermissions(functional, pID = None):
clazz = functional._permClass
rosterKey = functional.getRosterKey(pID=pID)
if rosterKey is not None:
team, _ = decodeRoster(rosterKey)
pInfo = functional.getPlayerInfo(pID=pID, rosterKey=rosterKey)
if pInfo is not None:
return clazz(roles=functional.getRoles(pDatabaseID=pInfo.dbID, clanDBID=pInfo.clanDBID, team=team), pState=pInfo.state, teamState=functional.getTeamState(team=team), hasLockedState=functional.hasLockedState())
return clazz()
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_control.getPrebattleTeamStates()
if team is not None and team < len(teamStates):
result = prb_items.TeamStateInfo(teamStates[team])
return result
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 createPermissions(functional, pID=None):
clazz = functional._permClass
rosterKey = functional.getRosterKey(pID=pID)
if rosterKey is not None:
team, _ = decodeRoster(rosterKey)
rosterInfo = functional.getPlayerInfo(pID=pID, rosterKey=rosterKey)
if rosterInfo is not None:
return clazz(
roles=functional.getRoles(pDatabaseID=rosterInfo.dbID),
pState=rosterInfo.state,
teamState=functional.getTeamState(team=team))
return clazz()
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, restriction = self.getLimits().isMaxCountValid(nextTeam, assigned)
if not result:
LOG_ERROR('Max count limit', nextTeam, assigned)
if callback:
callback(False)
return
ctx.startProcessing(callback)
BigWorld.player().prb_assign(ctx.getPlayerID(), ctx.getRoster(), ctx.onResponseReceived)
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, REQUEST_COOLDOWN.PREBATTLE_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, REQUEST_COOLDOWN.PREBATTLE_NOT_READY)
def _setPlayerNotReady(self, ctx, callback = None):
if info.isRequestInCoolDown(REQUEST_TYPE.SET_PLAYER_STATE):
SystemMessages.pushMessage(messages.getRequestInCoolDownMessage(REQUEST_TYPE.SET_PLAYER_STATE, REQUEST_COOLDOWN.PREBATTLE_NOT_READY), type=SystemMessages.SM_TYPE.Error)
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)
info.setRequestCoolDown(REQUEST_TYPE.SET_PLAYER_STATE, coolDown=REQUEST_COOLDOWN.PREBATTLE_NOT_READY)
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 _setPlayerReady(self, ctx, callback=None):
"""
Sets player state to ready.
Args:
ctx: set player state request context
callback: operation callback
"""
if prb_getters.isParentControlActivated():
g_eventDispatcher.showParentControlNotification()
if callback:
callback(False)
return
elif self._cooldown.validate(REQUEST_TYPE.SET_PLAYER_STATE,
REQUEST_COOLDOWN.PREBATTLE_NOT_READY):
if callback:
callback(False)
return
else:
if ctx.doVehicleValidation():
result = self._limits.isVehicleValid()
if result is not None and not result.isValid:
if not ctx.isInitial():
SystemMessages.pushMessage(
messages.getInvalidVehicleMessage(
result.restriction, self),
type=SystemMessages.SM_TYPE.Error)
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)
self._cooldown.process(
REQUEST_TYPE.SET_PLAYER_STATE,
coolDown=REQUEST_COOLDOWN.PREBATTLE_NOT_READY)
return
def _getPlayersStateStats(self, rosterKey):
clientPrb = prb_control.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)
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 onPlayerStateChanged(self, functional, roster, playerInfo):
team, assigned = decodeRoster(roster)
data = {'uid': playerInfo.dbID,
'state': playerInfo.state,
'icon': '',
'vShortName': '',
'vLevel': '',
'vType': ''}
if playerInfo.isVehicleSpecified():
vehicle = playerInfo.getVehicle()
data.update({'icon': vehicle.iconContour,
'vShortName': vehicle.shortUserName,
'vLevel': int2roman(vehicle.level),
'vType': vehicle.type})
self.as_setPlayerStateS(team, assigned, data)
if playerInfo.isCurrentPlayer():
self.as_toggleReadyBtnS(not playerInfo.isReady())
else:
chat = self.chat
if chat:
chat.as_addMessageS(messages.getPlayerStateChangedMessage(self.__prbName, playerInfo))
def _setPlayerReady(self, ctx, callback = None):
if isParentControlActivated():
events_dispatcher.showParentControlNotification()
if callback:
callback(False)
return
isValid, notValidReason = self._limits.isVehicleValid()
if not isValid:
SystemMessages.pushMessage(messages.getInvalidVehicleMessage(notValidReason, self), type=SystemMessages.SM_TYPE.Error)
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 __init__(self, prbFunctional):
super(SquadActionButtonStateVO, self).__init__()
stateString = ''
pInfo = prbFunctional.getPlayerInfo()
team, assigned = decodeRoster(prbFunctional.getRosterKey())
isInQueue = prbFunctional.getTeamState().isInQueue()
isEnabled = g_currentVehicle.isReadyToPrebattle() and not (isInQueue and assigned)
if not g_currentVehicle.isPresent():
stateString = i18n.makeString(CYBERSPORT.WINDOW_UNIT_MESSAGE_NOVEHICLE)
elif not g_currentVehicle.isReadyToPrebattle():
stateString = i18n.makeString(CYBERSPORT.WINDOW_UNIT_MESSAGE_VEHICLEINNOTREADY)
elif not pInfo.isReady():
stateString = i18n.makeString(MESSENGER.DIALOGS_SQUAD_MESSAGE_GETREADY)
elif pInfo.isReady() and not isInQueue:
stateString = i18n.makeString(MESSENGER.DIALOGS_SQUAD_MESSAGE_GETNOTREADY)
if pInfo.isReady():
label = CYBERSPORT.WINDOW_UNIT_NOTREADY
else:
label = CYBERSPORT.WINDOW_UNIT_READY
self['stateString'] = stateString
self['label'] = label
self['isEnabled'] = isEnabled
self['isReady'] = pInfo.isReady()
def isLeaveBtnEnabled(self):
functional = self.prbFunctional
team, assigned = decodeRoster(functional.getRosterKey())
return not (functional.getTeamState().isInQueue()
and functional.getPlayerInfo().isReady() and assigned)
def isReadyBtnEnabled(self):
functional = self.prbFunctional
team, assigned = decodeRoster(functional.getRosterKey())
return g_currentVehicle.isReadyToPrebattle() and not (functional.getTeamState().isInQueue() and assigned)
def isLeaveBtnEnabled(self):
entity = self.prbEntity
_, assigned = decodeRoster(entity.getRosterKey())
return not (entity.getTeamState().isInQueue()
and entity.getPlayerInfo().isReady() and assigned)
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 hasLockedState(self):
team, assigned = decodeRoster(self.getRosterKey())
return self.getTeamState().isInQueue() and self.getPlayerInfo().isReady() and assigned
def hasLockedState(self):
team, assigned = decodeRoster(self.getRosterKey())
return self.getTeamState().isInQueue() and self.getPlayerInfo().isReady() and assigned
def hasLockedState(self):
if g_playerEvents.isPlayerEntityChanging:
return True
_, assigned = decodeRoster(self.getRosterKey())
return self.getTeamState().isInQueue() and self.getPlayerInfo().isReady() and assigned
def isReadyBtnEnabled(self):
entity = self.prbEntity
_, assigned = decodeRoster(entity.getRosterKey())
return g_currentVehicle.isReadyToPrebattle() and not (
entity.getTeamState().isInQueue() and assigned)
def _isInviteBtnEnabled(self):
functional = self.prbFunctional
(team, assigned,) = decodeRoster(functional.getRosterKey())
return not (functional.getTeamState().isInQueue() and functional.getPlayerInfo().isReady() and assigned) and self.canSendInvite()
def isReadyBtnEnabled(self):
functional = self.prbFunctional
team, assigned = decodeRoster(functional.getRosterKey())
return g_currentVehicle.isReadyToPrebattle() and not (
functional.getTeamState().isInQueue() and assigned)
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 isLeaveBtnEnabled(self):
functional = self.prbFunctional
team, assigned = decodeRoster(functional.getRosterKey())
return not (functional.getTeamState().isInQueue() and functional.getPlayerInfo().isReady() and assigned)
def onTeamStatesReceived(self, entity, team1State, team2State):
_, assigned = decodeRoster(entity.getRosterKey())
if team1State.isInQueue() and team2State.isInQueue() and assigned:
self.as_disableControlsS(True)
elif assigned is False:
self.as_enabledCloseButtonS(True)
def onTeamStatesReceived(self, functional, team1State, team2State):
team, assigned = decodeRoster(functional.getRosterKey())
if team1State.isInQueue() and team2State.isInQueue() and assigned:
self.as_disableControlsS(True)
elif assigned is False:
self.as_enabledCloseButtonS(True)
