def createFunctional(self, dispatcher, ctx):
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
if prb_control.isPrebattleSettingsReceived(prebattle=clientPrb):
prbSettings = prb_control.getPrebattleSettings(prebattle=clientPrb)
prbType = prb_control.getPrebattleType(settings=prbSettings)
clazz = None
if prbType in _SUPPORTED_FUNCTIONAL:
clazz = _SUPPORTED_FUNCTIONAL[prbType]
if clazz:
prbFunctional = clazz(prbSettings)
for listener in dispatcher._globalListeners:
prbFunctional.addListener(listener())
createParams = ctx.getCreateParams()
if 'settings' in createParams and isStatefulFunctional(prbFunctional):
guiSettings = createParams['settings']
if guiSettings:
prbFunctional.applyStates(guiSettings.get(CTRL_ENTITY_TYPE.PREBATTLE))
else:
LOG_ERROR('Prebattle with given type is not supported', prbType)
prbFunctional = PrbNotSupportedFunctional(prbSettings)
else:
prbFunctional = PrbInitFunctional()
else:
prbType = ctx.getPrbType()
clazz = None
if prbType in _SUPPORTED_INTRO:
clazz = _SUPPORTED_INTRO[prbType]
if clazz is None:
clazz = NoPrbFunctional
prbFunctional = clazz()
return prbFunctional
def fini(self, clientPrb = None, woEvents = False):
self.__dispatcher = None
if clientPrb is None:
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
clientPrb.onSettingsReceived -= self.prb_onSettingsReceived
clientPrb.onRosterReceived -= self.prb_onRosterReceived
def fini(self, clientPrb = None, woEvents = False):
self._hasEntity = False
self._settings = None
super(PrbDispatcher, self).fini(clientPrb, woEvents)
if self._limits is not None:
self._limits.clear()
self._limits = None
if not woEvents:
try:
for listener in self._listeners:
listener.onPrbFunctionalFinished()
except:
LOG_CURRENT_EXCEPTION()
if clientPrb is None:
clientPrb = prb_control.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
def fini(self, clientPrb = None, woEvents = False):
self._hasEntity = False
self._settings = None
super(PrbDispatcher, self).fini(clientPrb, woEvents)
if self._limits is not None:
self._limits.clear()
self._limits = None
if not woEvents:
try:
for listener in self._listeners:
listener.onPrbFunctionalFinished()
except:
LOG_CURRENT_EXCEPTION()
if clientPrb is None:
clientPrb = prb_control.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
def fini(self, clientPrb = None, woEvents = False):
self.__dispatcher = None
if clientPrb is None:
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
clientPrb.onSettingsReceived -= self.prb_onSettingsReceived
clientPrb.onRosterReceived -= self.prb_onRosterReceived
def create(self, ctx, callback=None):
if not isinstance(ctx, TrainingSettingsCtx):
LOG_ERROR('Invalid context to create training', ctx)
if callback:
callback(False)
elif info.isRequestInCoolDown(REQUEST_TYPE.CREATE):
SystemMessages.pushMessage(messages.getJoinFailureMessage(
JOIN_FAILURE.COOLDOWN),
type=SystemMessages.SM_TYPE.Error)
if callback:
callback(False)
elif prb_control.getClientPrebattle() is None or ctx.isForced():
ctx.startProcessing(callback=callback)
BigWorld.player().prb_createTraining(ctx.getArenaTypeID(),
ctx.getRoundLen(),
ctx.isOpened(),
ctx.getComment())
info.setRequestCoolDown(
REQUEST_TYPE.CREATE,
coolDown=REQUEST_COOLDOWN.PREBATTLE_CREATION)
else:
LOG_ERROR(
'First, player has to confirm exit from the current prebattle',
prb_control.getPrebattleType())
if callback:
callback(False)
return
def _canAddPlayers(self):
clientPrb = prb_control.getClientPrebattle()
result = False
if clientPrb is not None:
settings = prb_control.getPrebattleSettings(prebattle=clientPrb)
rosters = prb_control.getPrebattleRosters(prebattle=clientPrb)
result, _ = MaxCount().check(rosters, 1, settings.getTeamLimits(1))
return result
def join(self, ctx, callback = None):
if prb_control.getClientPrebattle() is None or ctx.isForced():
ctx.startProcessing(callback=callback)
BigWorld.player().prb_join(ctx.getID())
else:
LOG_ERROR('First, player has to confirm exit from the current prebattle', prb_control.getPrebattleType())
if callback:
callback(False)
def _canAddPlayers(self):
clientPrb = prb_control.getClientPrebattle()
result = False
if clientPrb is not None:
settings = prb_control.getPrebattleSettings(prebattle=clientPrb)
rosters = prb_control.getPrebattleRosters(prebattle=clientPrb)
result, _ = MaxCount().check(rosters, 1, settings.getTeamLimits(1))
return result
def join(self, ctx, callback = None):
if prb_control.getClientPrebattle() is None or ctx.isForced():
ctx.startProcessing(callback=callback)
BigWorld.player().prb_join(ctx.getID())
else:
LOG_ERROR('First, player has to confirm exit from the current prebattle', prb_control.getPrebattleType())
if callback:
callback(False)
def canAssignToTeam(self, team = 1):
clientPrb = prb_control.getClientPrebattle()
result = False
if clientPrb is not None:
settings = prb_control.getPrebattleSettings(prebattle=clientPrb)
rosters = prb_control.getPrebattleRosters(prebattle=clientPrb)
prbType = prb_control.getPrebattleType(clientPrb, settings)
result, _ = TeamNoPlayersInBattle(prbType).check(rosters, team, settings.getTeamLimits(team))
return result
def pe_onPrebattleJoined(self):
clientPrb = getClientPrebattle()
if clientPrb:
self.__prbFunctional.fini()
self.__prbFunctional = functional.createPrbFunctional(self)
self.__prbFunctional.init()
else:
LOG_ERROR('ClientPrebattle is not defined')
self.__requestCtx.stopProcessing(result=False)
def pe_onPrebattleJoined(self):
clientPrb = getClientPrebattle()
if clientPrb:
self.__prbFunctional.fini()
self.__prbFunctional = functional.createPrbFunctional(self)
self.__prbFunctional.init()
else:
LOG_ERROR('ClientPrebattle is not defined')
self.__requestCtx.stopProcessing(result=False)
def canAssignToTeam(self, team=1):
clientPrb = prb_control.getClientPrebattle()
result = False
if clientPrb is not None:
settings = prb_control.getPrebattleSettings(prebattle=clientPrb)
rosters = prb_control.getPrebattleRosters(prebattle=clientPrb)
prbType = prb_control.getPrebattleType(clientPrb, settings)
result, _ = TeamNoPlayersInBattle(prbType).check(
rosters, team, settings.getTeamLimits(team))
return result
def init(self, clientPrb = None, ctx = None):
if clientPrb is None:
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
clientPrb.onSettingsReceived += self.prb_onSettingsReceived
clientPrb.onRosterReceived += self.prb_onRosterReceived
if prb_control.isPrebattleSettingsReceived(prebattle=clientPrb):
self.prb_onSettingsReceived()
if len(prb_control.getPrebattleRosters(prebattle=clientPrb)):
self.prb_onRosterReceived()
return FUNCTIONAL_INIT_RESULT.INITED
def init(self, clientPrb = None, ctx = None):
if clientPrb is None:
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
clientPrb.onSettingsReceived += self.prb_onSettingsReceived
clientPrb.onRosterReceived += self.prb_onRosterReceived
if prb_control.isPrebattleSettingsReceived(prebattle=clientPrb):
self.prb_onSettingsReceived()
if len(prb_control.getPrebattleRosters(prebattle=clientPrb)):
self.prb_onRosterReceived()
return FUNCTIONAL_INIT_RESULT.INITED
def create(self, ctx, callback = None):
if prb_cooldown.validatePrbCreationCooldown():
if callback:
callback(False)
elif getClientPrebattle() is None or ctx.isForced():
ctx.startProcessing(callback=callback)
BigWorld.player().prb_createEventSquad()
prb_cooldown.setPrbCreationCooldown()
else:
LOG_ERROR('First, player has to confirm exit from the current prebattle', getPrebattleType())
if callback:
callback(False)
def __checkPrebattleLockedVehicle(self):
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
rosters = prb_control.getPrebattleRosters(prebattle=clientPrb)
for rId, roster in rosters.iteritems():
if BigWorld.player().id in roster:
vehCompDescr = roster[BigWorld.player().id].get('vehCompDescr', '')
if len(vehCompDescr):
vehDescr = vehicles.VehicleDescr(vehCompDescr)
vehicle = g_itemsCache.items.getItemByCD(vehDescr.type.compactDescr)
if vehicle is not None:
return vehicle.invID
return 0
def doAction(self, action, dispatcher = None):
if action.actionName == PREBATTLE_ACTION_NAME.LEAVE_TRAINING_LIST:
events_dispatcher.loadHangar()
elif prb_control.getClientPrebattle() is None:
self.__loadTrainingList()
elif prb_control.isTraining():
if dispatcher is not None:
self.__loadTrainingRoom(dispatcher)
else:
LOG_ERROR('Dispatcher not found')
else:
LOG_ERROR('Player is joined to prebattle', prb_control.getPrebattleType())
return True
def __checkPrebattleLockedVehicle(self):
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
rosters = prb_control.getPrebattleRosters(prebattle=clientPrb)
for rId, roster in rosters.iteritems():
if BigWorld.player().id in roster:
vehCompDescr = roster[BigWorld.player().id].get('vehCompDescr', '')
if len(vehCompDescr):
vehDescr = vehicles.VehicleDescr(vehCompDescr)
vehicle = g_itemsCache.items.getItemByCD(vehDescr.type.compactDescr)
if vehicle is not None:
return vehicle.invID
return 0
def doAction(self, action, dispatcher=None):
if action.actionName == PREBATTLE_ACTION_NAME.LEAVE_TRAINING_LIST:
events_dispatcher.loadHangar()
elif prb_control.getClientPrebattle() is None:
self.__loadTrainingList()
elif prb_control.isTraining():
if dispatcher is not None:
self.__loadTrainingRoom(dispatcher)
else:
LOG_ERROR('Dispatcher not found')
else:
LOG_ERROR('Player is joined to prebattle',
prb_control.getPrebattleType())
return True
def pe_onPrebattleJoined(self):
clientPrb = getClientPrebattle()
if clientPrb:
prbFunctional = self.getFunctional(CTRL_ENTITY_TYPE.PREBATTLE)
if prbFunctional:
if self.__requestCtx and self.__requestCtx.getPrbType() == prbFunctional.getPrbType():
exit = FUNCTIONAL_EXIT.PREBATTLE
else:
exit = FUNCTIONAL_EXIT.NO_FUNC
prbFunctional.setExit(exit)
else:
LOG_ERROR('Prebattle functional is not found')
self.__factories.createFunctional(self, CreateFunctionalCtx(CTRL_ENTITY_TYPE.PREBATTLE))
else:
LOG_ERROR('ClientPrebattle is not defined')
self.__requestCtx.stopProcessing(result=False)
def create(self, ctx, callback=None):
if prb_cooldown.validatePrbCreationCooldown():
if callback:
callback(False)
elif getClientPrebattle() is None or ctx.isForced():
ctx.startProcessing(callback=callback)
BigWorld.player().prb_createCompany(ctx.isOpened(),
ctx.getComment(),
ctx.getDivision())
prb_cooldown.setPrbCreationCooldown()
else:
LOG_ERROR(
'First, player has to confirm exit from the current prebattle',
getPrebattleType())
if callback:
callback(False)
def create(self, ctx, callback = None):
if not isinstance(ctx, prb_ctx.TrainingSettingsCtx):
LOG_ERROR('Invalid context to create training', ctx)
if callback:
callback(False)
elif prb_cooldown.validatePrbCreationCooldown():
if callback:
callback(False)
elif getClientPrebattle() is None or ctx.isForced():
ctx.startProcessing(callback=callback)
BigWorld.player().prb_createTraining(ctx.getArenaTypeID(), ctx.getRoundLen(), ctx.isOpened(), ctx.getComment())
prb_cooldown.setPrbCreationCooldown()
else:
LOG_ERROR('First, player has to confirm exit from the current prebattle', getPrebattleType())
if callback:
callback(False)
def create(self, ctx, callback = None):
if not isinstance(ctx, context.SquadSettingsCtx):
LOG_ERROR('Invalid context to create squad', ctx)
if callback:
callback(False)
elif info.isRequestInCoolDown(REQUEST_TYPE.CREATE):
SystemMessages.pushMessage(messages.getJoinFailureMessage(JOIN_FAILURE.COOLDOWN), type=SystemMessages.SM_TYPE.Error)
if callback:
callback(False)
elif prb_control.getClientPrebattle() is None or ctx.isForced():
ctx.startProcessing(callback=callback)
BigWorld.player().prb_createSquad()
info.setRequestCoolDown(REQUEST_TYPE.CREATE, coolDown=REQUEST_COOLDOWN.PREBATTLE_CREATION)
else:
LOG_ERROR('First, player has to confirm exit from the current prebattle', prb_control.getPrebattleType())
if callback:
callback(False)
return
def init(self, clientPrb = None, ctx = None):
if clientPrb is None:
clientPrb = prb_control.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
for listener in self._listeners:
listener.onPrbFunctionalInited()
else:
LOG_ERROR('ClientPrebattle is not defined')
return
def pe_onPrebattleJoined(self):
clientPrb = getClientPrebattle()
if clientPrb:
prbFunctional = self.getFunctional(CTRL_ENTITY_TYPE.PREBATTLE)
if prbFunctional:
if self.__requestCtx and self.__requestCtx.getPrbType(
) == prbFunctional.getPrbType():
exit = FUNCTIONAL_EXIT.PREBATTLE
else:
exit = FUNCTIONAL_EXIT.NO_FUNC
prbFunctional.setExit(exit)
else:
LOG_ERROR('Prebattle functional is not found')
self.__factories.createFunctional(
self, CreateFunctionalCtx(CTRL_ENTITY_TYPE.PREBATTLE))
else:
LOG_ERROR('ClientPrebattle is not defined')
self.__requestCtx.stopProcessing(result=False)
def init(self, clientPrb = None, ctx = None):
self._hasEntity = True
if clientPrb is None:
clientPrb = prb_control.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
for listener in self._listeners:
listener.onPrbFunctionalInited()
else:
LOG_ERROR('ClientPrebattle is not defined')
return FUNCTIONAL_INIT_RESULT.INITED
def createPrbFunctional(dispatcher):
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
if prb_control.isPrebattleSettingsReceived(prebattle=clientPrb):
prbSettings = prb_control.getPrebattleSettings(prebattle=clientPrb)
prbType = prb_control.getPrebattleType(settings=prbSettings)
if prbType in _SUPPORTED_PREBATTLE:
prbFunctional = _SUPPORTED_PREBATTLE[prbType][1](prbSettings)
for listener in dispatcher._globalListeners:
prbFunctional.addListener(listener())
else:
LOG_ERROR('Prebattle with given type is not supported', prbType)
prbFunctional = PrbNotSupportedFunctional(prbSettings)
else:
prbFunctional = PrbInitFunctional()
else:
prbFunctional = NoPrbFunctional()
return prbFunctional
def createPrbFunctional(dispatcher):
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
if prb_control.isPrebattleSettingsReceived(prebattle=clientPrb):
prbSettings = prb_control.getPrebattleSettings(prebattle=clientPrb)
prbType = prb_control.getPrebattleType(settings=prbSettings)
if prbType in _SUPPORTED_PREBATTLE:
prbFunctional = _SUPPORTED_PREBATTLE[prbType][1](prbSettings)
for listener in dispatcher._globalListeners:
prbFunctional.addListener(listener())
else:
LOG_ERROR("Prebattle with given type is not supported", prbType)
prbFunctional = PrbNotSupportedFunctional(prbSettings)
else:
prbFunctional = PrbInitFunctional()
else:
prbFunctional = NoPrbFunctional()
return prbFunctional
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 _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 create(self, ctx, callback=None):
if not isinstance(ctx, prb_ctx.TrainingSettingsCtx):
LOG_ERROR('Invalid context to create training', ctx)
if callback:
callback(False)
elif prb_cooldown.validatePrbCreationCooldown():
if callback:
callback(False)
elif getClientPrebattle() is None or ctx.isForced():
ctx.startProcessing(callback=callback)
BigWorld.player().prb_createTraining(ctx.getArenaTypeID(),
ctx.getRoundLen(),
ctx.isOpened(),
ctx.getComment())
prb_cooldown.setPrbCreationCooldown()
else:
LOG_ERROR(
'First, player has to confirm exit from the current prebattle',
getPrebattleType())
if callback:
callback(False)
def createFunctional(self, dispatcher, ctx):
clientPrb = prb_control.getClientPrebattle()
if clientPrb is not None:
if prb_control.isPrebattleSettingsReceived(prebattle=clientPrb):
prbSettings = prb_control.getPrebattleSettings(
prebattle=clientPrb)
prbType = prb_control.getPrebattleType(settings=prbSettings)
clazz = None
if prbType in _SUPPORTED_FUNCTIONAL:
clazz = _SUPPORTED_FUNCTIONAL[prbType]
if clazz:
prbFunctional = clazz(prbSettings)
for listener in dispatcher._globalListeners:
prbFunctional.addListener(listener())
createParams = ctx.getCreateParams()
if 'settings' in createParams and isStatefulFunctional(
prbFunctional):
guiSettings = createParams['settings']
if guiSettings:
prbFunctional.applyStates(
guiSettings.get(CTRL_ENTITY_TYPE.PREBATTLE))
else:
LOG_ERROR('Prebattle with given type is not supported',
prbType)
prbFunctional = PrbNotSupportedFunctional(prbSettings)
else:
prbFunctional = PrbInitFunctional()
else:
prbType = ctx.getPrbType()
clazz = None
if prbType in _SUPPORTED_INTRO:
clazz = _SUPPORTED_INTRO[prbType]
if clazz is None:
clazz = NoPrbFunctional
prbFunctional = clazz()
return prbFunctional
