def init(self):
g_clientUpdateManager.addCallbacks({"inventory": self.onInventoryUpdate, "cache.vehsLock": self.onLocksUpdate})
game_control.g_instance.igr.onIgrTypeChanged += self.onIgrTypeChanged
game_control.g_instance.rentals.onRentChangeNotify += self.onRentChange
game_control.getFalloutCtrl().onSettingsChanged += self.__onFalloutChanged
prbVehicle = self.__checkPrebattleLockedVehicle()
storedVehInvID = AccountSettings.getFavorites(CURRENT_VEHICLE)
self.selectVehicle(prbVehicle or storedVehInvID)
def destroy(self):
self.__vehInvID = 0
self.__clearChangeCallback()
self.onChanged.clear()
self.onChangeStarted.clear()
g_clientUpdateManager.removeObjectCallbacks(self)
game_control.g_instance.igr.onIgrTypeChanged -= self.onIgrTypeChanged
game_control.g_instance.rentals.onRentChangeNotify -= self.onRentChange
game_control.getFalloutCtrl().onSettingsChanged -= self.__onFalloutChanged
_getHangarSpace().removeVehicle()
self.selectNoVehicle()
def destroy(self):
self.__vehInvID = 0
self.__clearChangeCallback()
self.onChanged.clear()
self.onChangeStarted.clear()
g_clientUpdateManager.removeObjectCallbacks(self)
game_control.g_instance.igr.onIgrTypeChanged -= self.onIgrTypeChanged
game_control.g_instance.rentals.onRentChangeNotify -= self.onRentChange
game_control.getFalloutCtrl(
).onSettingsChanged -= self.__onFalloutChanged
_getHangarSpace().removeVehicle()
self.selectNoVehicle()
def init(self):
g_clientUpdateManager.addCallbacks({
'inventory': self.onInventoryUpdate,
'cache.vehsLock': self.onLocksUpdate
})
game_control.g_instance.igr.onIgrTypeChanged += self.onIgrTypeChanged
game_control.g_instance.rentals.onRentChangeNotify += self.onRentChange
game_control.getFalloutCtrl(
).onSettingsChanged += self.__onFalloutChanged
prbVehicle = self.__checkPrebattleLockedVehicle()
storedVehInvID = AccountSettings.getFavorites(CURRENT_VEHICLE)
self.selectVehicle(prbVehicle or storedVehInvID)
def __getFightBtnTooltipData(self, state):
falloutCtrl = getFalloutCtrl()
config = falloutCtrl.getConfig()
if state == PREBATTLE_RESTRICTION.VEHICLE_FALLOUT_ONLY:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutOnly/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutOnly/body')
elif state == PREBATTLE_RESTRICTION.FALLOUT_NOT_SELECTED:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotSelected/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotSelected/body')
elif state == PREBATTLE_RESTRICTION.VEHICLE_GROUP_IS_NOT_READY:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotReady/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotReady/body')
elif state == UNIT_RESTRICTION.FALLOUT_NOT_ENOUGH_PLAYERS:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotEnoughPlayer/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotEnoughPlayer/body')
elif state == UNIT_RESTRICTION.FALLOUT_VEHICLE_LEVEL_REQUIRED:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/body', level=int2roman(config.vehicleLevelRequired))
elif state == UNIT_RESTRICTION.FALLOUT_VEHICLE_MIN:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehMin/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehMin/body', min=str(config.minVehiclesPerPlayer), level=toRomanRangeString(list(config.allowedLevels), 1))
else:
return None
return {'header': header,
'body': body,
'note': ''}
def _populate(self):
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onSettingsChanged += self.__onSettingsChanged
self.__falloutCtrl.onVehiclesChanged += self.__onVehiclesChanged
self.as_isFalloutS(True)
super(FalloutSquadView, self)._populate()
self.__updateHeader()
def wrapper(*args, **kwargs):
res = yield checkAmmoLevel(getFalloutCtrl().getSelectedVehicles())
if res:
func(*args, **kwargs)
elif kwargs.get('callback') is not None:
kwargs.get('callback')(False)
return
def _populate(self):
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onSettingsChanged += self.__onSettingsChanged
self.__falloutCtrl.onVehiclesChanged += self.__onVehiclesChanged
self.as_isFalloutS(True)
super(FalloutSquadView, self)._populate()
self.__updateHeader()
def showVehicles(self):
filterCriteria = REQ_CRITERIA.INVENTORY
if self.__vehiclesFilter['nation'] != -1:
if self.__vehiclesFilter['nation'] == 100:
filterCriteria |= REQ_CRITERIA.VEHICLE.IS_PREMIUM_IGR
else:
filterCriteria |= REQ_CRITERIA.NATIONS([self.__vehiclesFilter['nation']])
if self.__vehiclesFilter['tankType'] != 'none':
filterCriteria |= REQ_CRITERIA.VEHICLE.CLASSES([self.__vehiclesFilter['tankType']])
if self.__vehiclesFilter['ready']:
filterCriteria |= REQ_CRITERIA.VEHICLE.FAVORITE
if self.__vehiclesFilter['gameModeFilter'] and self.__multiselectionMode:
filterCriteria |= REQ_CRITERIA.VEHICLE.FALLOUT.AVAILABLE
if not getFalloutCtrl().isSelected():
filterCriteria |= ~REQ_CRITERIA.VEHICLE.ONLY_FOR_FALLOUT
items = g_itemsCache.items
filteredVehs = items.getVehicles(filterCriteria)
def sorting(v1, v2):
if v1.isFavorite and not v2.isFavorite:
return -1
if not v1.isFavorite and v2.isFavorite:
return 1
return v1.__cmp__(v2)
vehsCDs = map(attrgetter('intCD'), sorted(filteredVehs.values(), sorting))
LOG_DEBUG('Showing carousel vehicles: ', vehsCDs)
self.as_showVehiclesS(vehsCDs)
def getHangarMessage(self):
if not self.isPresent():
return (Vehicle.VEHICLE_STATE.NOT_PRESENT,
MENU.CURRENTVEHICLESTATUS_NOTPRESENT,
Vehicle.VEHICLE_STATE_LEVEL.CRITICAL)
state, stateLvl = self.item.getState()
if state == Vehicle.VEHICLE_STATE.IN_PREMIUM_IGR_ONLY:
icon = icons.premiumIgrBig()
if self.item.isRented:
rentLeftStr = getTimeLeftStr('#menu:vehicle/igrRentLeft/%s',
self.item.rentInfo.getTimeLeft())
message = i18n.makeString('#menu:currentVehicleStatus/' +
state,
icon=icon,
time=rentLeftStr)
else:
message = i18n.makeString(
'#menu:tankCarousel/vehicleStates/inPremiumIgrOnly',
icon=icon)
return (state, message, stateLvl)
falloutCtrl = getFalloutCtrl()
if falloutCtrl and falloutCtrl.isSelected():
if not self.item.isFalloutAvailable or self.item.getCustomState(
) == Vehicle.VEHICLE_STATE.UNSUITABLE_TO_QUEUE:
message = i18n.makeString(
'#menu:tankCarousel/vehicleStates/%s' %
Vehicle.VEHICLE_STATE.NOT_SUITABLE)
return (state, message, Vehicle.VEHICLE_STATE_LEVEL.WARNING)
message = '#menu:currentVehicleStatus/' + state
return (state, message, stateLvl)
def __getFightBtnTooltipData(self, state):
falloutCtrl = getFalloutCtrl()
config = falloutCtrl.getConfig()
if state == PREBATTLE_RESTRICTION.VEHICLE_FALLOUT_ONLY:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutOnly/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutOnly/body')
elif state == PREBATTLE_RESTRICTION.FALLOUT_NOT_SELECTED:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotSelected/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotSelected/body')
elif state == PREBATTLE_RESTRICTION.VEHICLE_GROUP_IS_NOT_READY:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotReady/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotReady/body')
elif state == UNIT_RESTRICTION.FALLOUT_NOT_ENOUGH_PLAYERS:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotEnoughPlayer/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutNotEnoughPlayer/body')
elif state in (UNIT_RESTRICTION.FALLOUT_VEHICLE_LEVEL_REQUIRED, PREBATTLE_RESTRICTION.VEHICLE_GROUP_REQUIRED):
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/body', level=int2roman(config.vehicleLevelRequired))
elif state in (UNIT_RESTRICTION.FALLOUT_VEHICLE_MIN, PREBATTLE_RESTRICTION.VEHICLE_GROUP_MIN):
allowedLevelsList = list(config.allowedLevels)
if len(allowedLevelsList) > 1:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehMin/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehMin/body', min=str(config.minVehiclesPerPlayer), level=toRomanRangeString(allowedLevelsList, 1))
else:
header = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/header')
body = i18n.makeString('#menu:headerButtons/fightBtn/tooltip/falloutVehLevelRequired/body', level=int2roman(config.vehicleLevelRequired))
else:
return None
return {makeTooltip(header, body)}
def __onItemsChanged(self, updateReason, invalidItems):
vehiclesDiff = invalidItems.get(GUI_ITEM_TYPE.VEHICLE)
if vehiclesDiff is not None:
falloutVehicle = findFirst(lambda v: v.intCD in vehiclesDiff, getFalloutCtrl().getSelectedVehicles())
if falloutVehicle is not None:
self.__updatePrebattleControls()
return
def _getFalloutVehMinStr(self):
config = getFalloutCtrl().getConfig()
allowedLevelsList = list(config.allowedLevels)
if len(allowedLevelsList) > 1:
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTMIN_LEVELRANGE, {'level': toRomanRangeString(allowedLevelsList, 1)})
else:
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTMIN_REQUIREDLEVEL, {'level': int2roman(config.vehicleLevelRequired)})
def __updatePrebattleControls(self):
prbDispatcher = g_prbLoader.getDispatcher()
if not prbDispatcher:
return
items = battle_selector_items.getItems()
state = prbDispatcher.getFunctionalState()
selected = items.update(state)
canDo, canDoMsg = prbDispatcher.canPlayerDoAction()
playerInfo = prbDispatcher.getPlayerInfo()
if selected.isInSquad(state):
isInSquad = True
else:
isInSquad = False
isSqaudDisabled = state.hasLockedState or self.__falloutCtrl.isEnabled() and not self.__falloutCtrl.getBattleType()
self.as_doDisableHeaderButtonS(self.BUTTONS.SQUAD, not isSqaudDisabled)
falloutCtrl = getFalloutCtrl()
isFallout = falloutCtrl.isSelected()
if isInSquad:
tooltip = TOOLTIPS.HEADER_SQUAD_MEMBER
else:
tooltip = TOOLTIPS.HEADER_DOMINATIONSQUAD if isFallout else TOOLTIPS.HEADER_SQUAD
self.as_updateSquadS(isInSquad, tooltip, TOOLTIP_TYPES.COMPLEX)
isFightBtnDisabled = not canDo or selected.isFightButtonForcedDisabled()
if isFightBtnDisabled:
self.as_setFightBtnTooltipDataS(self.__getFightBtnTooltipData(canDoMsg))
else:
self.as_setFightBtnTooltipDataS(None)
self.as_disableFightButtonS(isFightBtnDisabled)
self.as_setFightButtonS(selected.getFightButtonLabel(state, playerInfo))
self.as_updateBattleTypeS(i18n.makeString(selected.getLabel()), selected.getSmallIcon(), not selected.isDisabled(), TOOLTIPS.HEADER_BATTLETYPE, TOOLTIP_TYPES.COMPLEX, selected.getData())
if selected.isDisabled():
self.__closeBattleTypeSelectPopover()
else:
self.__updateBattleTypeSelectPopover()
def unlock(self, funcExit, forced, callback = None):
state = self.getFunctionalState()
result = True
if state.hasModalEntity and (not state.isIntroMode or forced) and not (funcExit == FUNCTIONAL_EXIT.FALLOUT and state.isInFallout()):
factory = self.__factories.get(state.ctrlTypeID)
result = False
if factory:
ctx = factory.createLeaveCtx(funcExit)
if ctx:
meta = self.__collection.getItem(state.ctrlTypeID).getConfirmDialogMeta(funcExit)
if meta:
result = yield DialogsInterface.showDialog(meta)
else:
result = True
if result:
result = yield self.leave(ctx)
else:
LOG_ERROR('Can not create leave ctx', state)
else:
LOG_ERROR('Factory is not found', state)
if getFalloutCtrl().isEnabled() and not funcExit == FUNCTIONAL_EXIT.SQUAD:
g_eventDispatcher.unloadFallout()
if callback:
callback(result)
yield lambda callback = None: callback
return
def _populate(self):
battle_selector_items.create()
super(LobbyHeader, self)._populate()
self.app.containerManager.onViewAddedToContainer += self.__onViewAddedToContainer
game_control.g_instance.wallet.onWalletStatusChanged += self.__onWalletChanged
game_control.g_instance.gameSession.onPremiumNotify += self.__onPremiumTimeChanged
g_currentVehicle.onChanged += self.__onVehicleChanged
g_eventsCache.onSyncCompleted += self.__onEventsCacheResync
g_itemsCache.onSyncCompleted += self.__onItemsChanged
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onVehiclesChanged += self.__updateFalloutSettings
self.__falloutCtrl.onSettingsChanged += self.__updateFalloutSettings
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.CoolDownEvent.PREBATTLE, self.__handleSetPrebattleCoolDown, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.BubbleTooltipEvent.SHOW, self.__showBubbleTooltip, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.CloseWindowEvent.GOLD_FISH_CLOSED, self.__onGoldFishWindowClosed, scope=EVENT_BUS_SCOPE.LOBBY)
g_clientUpdateManager.addCallbacks({'stats.credits': self.__setCredits,
'stats.gold': self.__setGold,
'stats.freeXP': self.__setFreeXP,
'stats.clanInfo': self.__setClanInfo,
'goodies': self.__updateGoodies,
'account.premiumExpiryTime': self.__onPremiumExpireTimeChanged,
'cache.SPA': self.__onSPAUpdated})
self.as_setFightButtonS(i18n.makeString('#menu:headerButtons/battle'))
self.as_setWalletStatusS(game_control.g_instance.wallet.componentsStatuses)
self.updateAccountInfo()
self.startGlobalListening()
self.__updateServerName()
if not isTimeToShowGoldFishPromo():
enabledVal = isGoldFishActionActive()
tooltip = TOOLTIPS.HEADER_REFILL_ACTION if enabledVal else TOOLTIPS.HEADER_REFILL
self.as_setGoldFishEnabledS(enabledVal, False, tooltip, TOOLTIP_TYPES.COMPLEX)
Waiting.hide('enter')
def unlock(self, funcExit, forced, callback=None):
state = self.getFunctionalState()
result = True
if state.hasModalEntity and (not state.isIntroMode or forced) and not (
funcExit == FUNCTIONAL_EXIT.FALLOUT and state.isInFallout()):
factory = self.__factories.get(state.ctrlTypeID)
result = False
if factory:
ctx = factory.createLeaveCtx(funcExit)
if ctx:
meta = self.__collection.getItem(
state.ctrlTypeID).getConfirmDialogMeta(funcExit)
if meta:
result = yield DialogsInterface.showDialog(meta)
else:
result = True
if result:
result = yield self.leave(ctx)
else:
LOG_ERROR('Can not create leave ctx', state)
else:
LOG_ERROR('Factory is not found', state)
if getFalloutCtrl().isEnabled(
) and not funcExit == FUNCTIONAL_EXIT.SQUAD:
g_eventDispatcher.unloadFallout()
if callback:
callback(result)
yield lambda callback=None: callback
def _populate(self):
battle_selector_items.create()
super(LobbyHeader, self)._populate()
self.app.containerManager.onViewAddedToContainer += self.__onViewAddedToContainer
game_control.g_instance.wallet.onWalletStatusChanged += self.__onWalletChanged
game_control.g_instance.gameSession.onPremiumNotify += self.__onPremiumTimeChanged
g_currentVehicle.onChanged += self.__onVehicleChanged
g_eventsCache.onSyncCompleted += self.__onEventsCacheResync
g_itemsCache.onSyncCompleted += self.__onItemsChanged
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onVehiclesChanged += self.__updateFalloutSettings
self.__falloutCtrl.onSettingsChanged += self.__updateFalloutSettings
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.CoolDownEvent.PREBATTLE, self.__handleSetPrebattleCoolDown, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.BubbleTooltipEvent.SHOW, self.__showBubbleTooltip, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.CloseWindowEvent.GOLD_FISH_CLOSED, self.__onGoldFishWindowClosed, scope=EVENT_BUS_SCOPE.LOBBY)
g_clientUpdateManager.addCallbacks({'stats.credits': self.__setCredits,
'stats.gold': self.__setGold,
'stats.freeXP': self.__setFreeXP,
'stats.clanInfo': self.__setClanInfo,
'goodies': self.__updateGoodies,
'account.premiumExpiryTime': self.__onPremiumExpireTimeChanged,
'cache.SPA': self.__onSPAUpdated})
self.as_setFightButtonS(i18n.makeString('#menu:headerButtons/battle'))
self.as_setWalletStatusS(game_control.g_instance.wallet.componentsStatuses)
self.updateAccountInfo()
self.startGlobalListening()
self.__updateServerName()
if not isTimeToShowGoldFishPromo():
enabledVal = isGoldFishActionActive()
tooltip = TOOLTIPS.HEADER_REFILL_ACTION if enabledVal else TOOLTIPS.HEADER_REFILL
self.as_setGoldFishEnabledS(enabledVal, False, tooltip, TOOLTIP_TYPES.COMPLEX)
Waiting.hide('enter')
def _populate(self):
super(FalloutBattleSelectorWindow, self)._populate()
self.addListener(
events.HideWindowEvent.HIDE_BATTLE_SESSION_WINDOW,
self.__handleFalloutWindowHide,
scope=EVENT_BUS_SCOPE.LOBBY,
)
self.startGlobalListening()
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onSettingsChanged += self.__updateFalloutSettings
self.as_setInitDataS(
{
"windowTitle": FALLOUT.BATTLESELECTORWINDOW_TITLE,
"headerTitleStr": promoSubTitle(FALLOUT.BATTLESELECTORWINDOW_HEADERTITLESTR),
"headerDescStr": main(FALLOUT.BATTLESELECTORWINDOW_HEADERDESC),
"dominationBattleTitleStr": promoSubTitle(FALLOUT.BATTLESELECTORWINDOW_DOMINATION_TITLE),
"dominationBattleDescStr": main(FALLOUT.BATTLESELECTORWINDOW_DOMINATION_DESCR),
"dominationBattleBtnStr": FALLOUT.BATTLESELECTORWINDOW_DOMINATIONBATTLEBTNLBL,
"multiteamTitleStr": promoSubTitle(FALLOUT.BATTLESELECTORWINDOW_MULTITEAM_TITLE),
"multiteamDescStr": main(FALLOUT.BATTLESELECTORWINDOW_MULTITEAM_DESCR),
"multiteamBattleBtnStr": FALLOUT.BATTLESELECTORWINDOW_MULTITEAMBATTLEBTNLBL,
"bgImg": RES_ICONS.MAPS_ICONS_LOBBY_FALLOUTBATTLESELECTORBG,
}
)
if self.prbDispatcher.getFunctionalState().hasLockedState:
self.as_setBtnStatesS(
{"dominationBtnEnabled": False, "multiteamBtnEnabled": False, "closeBtnEnabled": False}
)
def _populate(self):
super(AmmunitionPanel, self)._populate()
g_clientUpdateManager.addCallbacks(
{'inventory': self.__inventoryUpdateCallBack})
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onSettingsChanged += self._updateFalloutSettings
self.update()
def _onUnloaded(self):
self.stopGlobalListening()
g_currentVehicle.onChanged -= self.__onVehicleChange
g_prbCtrlEvents.onVehicleClientStateChanged -= self.__onVehicleClientStateChanged
falloutCtrl = getFalloutCtrl()
if falloutCtrl is not None:
falloutCtrl.onSettingsChanged -= self.__onFalloutSettingsChanged
return
def __onItemsChanged(self, updateReason, invalidItems):
vehiclesDiff = invalidItems.get(GUI_ITEM_TYPE.VEHICLE)
if vehiclesDiff is not None:
falloutVehicle = findFirst(lambda v: v.intCD in vehiclesDiff,
getFalloutCtrl().getSelectedVehicles())
if falloutVehicle is not None:
self.__updatePrebattleControls()
return
def _onUnloaded(self):
self.stopGlobalListening()
g_currentVehicle.onChanged -= self.__onVehicleChange
g_prbCtrlEvents.onVehicleClientStateChanged -= self.__onVehicleClientStateChanged
falloutCtrl = getFalloutCtrl()
if falloutCtrl is not None:
falloutCtrl.onSettingsChanged -= self.__onFalloutSettingsChanged
return
def _populate(self):
super(FalloutBattleSelectorWindow, self)._populate()
self.startGlobalListening()
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onSettingsChanged += self.__updateFalloutSettings
self.__falloutCtrl.onAutomatchChanged += self.__updateFalloutSettings
self.__updateFalloutSettings()
if self.prbDispatcher.getFunctionalState().hasLockedState or not self.__falloutCtrl.canChangeBattleType():
self.as_setBtnStatesS(self.__getBtnsStateData(False))
def _populate(self):
self._falloutCtrl = getFalloutCtrl()
self._falloutCtrl.onVehiclesChanged += self._updateFalloutVehicles
self._falloutCtrl.onSettingsChanged += self._updateFalloutSettings
self._carouselDPConfig.update({'falloutCtrl': self._falloutCtrl})
super(FalloutTankCarousel, self)._populate()
self._slotDP = SlotDataProvider(self._falloutCtrl, self._itemsCache)
self._slotDP.setFlashObject(self.as_getMultiselectionDPS())
self._slotDP.buildList()
self.as_setMultiselectionInfoS(self.__getMultiselectionInfoVO())
def _populate(self):
self._falloutCtrl = getFalloutCtrl()
self._falloutCtrl.onVehiclesChanged += self._updateFalloutVehicles
self._falloutCtrl.onSettingsChanged += self._updateFalloutSettings
self._carouselDPConfig.update({'falloutCtrl': self._falloutCtrl})
super(FalloutTankCarousel, self)._populate()
self._slotDP = SlotDataProvider(self._falloutCtrl, self._itemsCache)
self._slotDP.setFlashObject(self.as_getMultiselectionDPS())
self._slotDP.buildList()
self.as_setMultiselectionInfoS(self.__getMultiselectionInfoVO())
def _onLoaded(self):
g_currentVehicle.onChanged += self.__onVehicleChange
if g_currentVehicle.item:
self.__updateText()
g_prbCtrlEvents.onVehicleClientStateChanged += self.__onVehicleClientStateChanged
falloutCtrl = getFalloutCtrl()
if falloutCtrl is not None:
falloutCtrl.onSettingsChanged += self.__onFalloutSettingsChanged
self.startGlobalListening()
return
def _onLoaded(self):
g_currentVehicle.onChanged += self.__onVehicleChange
if g_currentVehicle.item:
self.__updateText()
g_prbCtrlEvents.onVehicleClientStateChanged += self.__onVehicleClientStateChanged
falloutCtrl = getFalloutCtrl()
if falloutCtrl is not None:
falloutCtrl.onSettingsChanged += self.__onFalloutSettingsChanged
self.startGlobalListening()
return
def _populate(self):
super(FalloutBattleSelectorWindow, self)._populate()
self.addListener(events.HideWindowEvent.HIDE_BATTLE_SESSION_WINDOW, self.__handleFalloutWindowHide, scope=EVENT_BUS_SCOPE.LOBBY)
self.startGlobalListening()
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onSettingsChanged += self.__updateFalloutSettings
self.__falloutCtrl.onAutomatchChanged += self.__updateFalloutSettings
self.__updateFalloutSettings()
if self.prbDispatcher.getFunctionalState().hasLockedState or not self.__falloutCtrl.canChangeBattleType():
self.as_setBtnStatesS(self.__getBtnsStateData(False))
def __getVehicleStatus(self, showCustomStates, vehicle):
if showCustomStates:
isInInventory = vehicle.isInInventory
level = Vehicle.VEHICLE_STATE_LEVEL.WARNING
if not isInInventory and vehicle.hasRestoreCooldown(
) and vehicle.isHidden:
timeKey, formattedTime = getTimeLeftInfo(
self.vehicle.restoreInfo.getRestoreCooldownTimeLeft())
return {
'header':
_ms('#tooltips:vehicleStatus/restoreCooldown/%s' % timeKey,
time=formattedTime),
'text':
'',
'level':
level
}
isUnlocked = vehicle.isUnlocked
mayObtain, reason = vehicle.mayObtainForMoney(
g_itemsCache.items.stats.money)
msg = None
if not isUnlocked:
msg = 'notUnlocked'
elif isInInventory:
msg = 'inHangar'
elif not mayObtain:
level = Vehicle.VEHICLE_STATE_LEVEL.CRITICAL
if reason == 'gold_error':
msg = 'notEnoughGold'
elif reason == 'credits_error':
msg = 'notEnoughCredits'
else:
msg = 'operationError'
if msg is not None:
header, text = getComplexStatus('#tooltips:vehicleStatus/%s' %
msg)
return {'header': header, 'text': text, 'level': level}
return
else:
state, level = vehicle.getState()
if state == Vehicle.VEHICLE_STATE.SERVER_RESTRICTION:
return
isSuitableVeh = getFalloutCtrl().isSuitableVeh(vehicle)
if not isSuitableVeh:
header, text = getComplexStatus(
'#tooltips:vehicleStatus/%s' %
Vehicle.VEHICLE_STATE.NOT_SUITABLE)
level = Vehicle.VEHICLE_STATE_LEVEL.WARNING
else:
header, text = getComplexStatus('#tooltips:vehicleStatus/%s' %
state)
if header is None and text is None:
return
return {'header': header, 'text': text, 'level': level}
def _getFalloutVehMinStr(self):
config = getFalloutCtrl().getConfig()
allowedLevelsList = list(config.allowedLevels)
if len(allowedLevelsList) > 1:
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTMIN_LEVELRANGE, {
'level': toRomanRangeString(allowedLevelsList, 1)
})
else:
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTMIN_REQUIREDLEVEL, {
'level': int2roman(config.vehicleLevelRequired)
})
def check(self, teamLimits):
if g_currentVehicle.isFalloutOnly() and not getFalloutCtrl().isSelected():
return (False, PREBATTLE_RESTRICTION.VEHICLE_FALLOUT_ONLY)
if not g_currentVehicle.isReadyToFight():
return (False, PREBATTLE_RESTRICTION.VEHICLE_NOT_READY)
vehicle = g_currentVehicle.item
shellsList = []
for shell in vehicle.shells:
shellsList.extend([shell.intCD, shell.count])
return isVehicleValid(vehicle.descriptor, shellsList, teamLimits)
def doAction(self, action = None, dispatcher = None):
result = False
if action is not None:
actionName = action.actionName or _PAN.UNDEFINED
if actionName in (_PAN.JOIN_RANDOM_QUEUE, _PAN.UNDEFINED) and getFalloutCtrl().isSelected():
actionName = _PAN.JOIN_EVENT_BATTLES_QUEUE
if actionName in self.CREATE_QUEUE_BY_ACTION:
queueType, doAction = self.CREATE_QUEUE_BY_ACTION[actionName]
g_prbCtrlEvents.onPreQueueFunctionalCreated(queueType, doAction, action)
result = True
return result
def clear(self):
if self.isSubscribed:
self.stopGlobalListening()
g_eventBus.removeListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
g_currentVehicle.onChanged -= self.__onVehicleChanged
falloutCtrl = getFalloutCtrl()
falloutCtrl.onVehiclesChanged -= self.__updateFalloutSettings
falloutCtrl.onSettingsChanged -= self.__updateFalloutSettings
g_eventsCache.onSyncCompleted -= self.__onEventsCacheResync
game_control.g_instance.igr.onIgrTypeChanged -= self.__onIGRChanged
self.isSubscribed = False
self.isRunning = False
def clear(self):
if self.isSubscribed:
self.stopGlobalListening()
g_eventBus.removeListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
g_currentVehicle.onChanged -= self.__onVehicleChanged
falloutCtrl = getFalloutCtrl()
falloutCtrl.onVehiclesChanged -= self.__updateFalloutSettings
falloutCtrl.onSettingsChanged -= self.__updateFalloutSettings
g_eventsCache.onSyncCompleted -= self.__onEventsCacheResync
game_control.g_instance.igr.onIgrTypeChanged -= self.__onIGRChanged
self.isSubscribed = False
self.isRunning = False
def _populate(self):
super(TankCarousel, self)._populate()
if self.__updateVehiclesTimerId is not None:
BigWorld.cancelCallback(self.__updateVehiclesTimerId)
self.__updateVehiclesTimerId = None
g_gameCtrl.rentals.onRentChangeNotify += self._updateRent
g_gameCtrl.igr.onIgrTypeChanged += self._updateIgrType
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onVehiclesChanged += self._updateFalloutSettings
self.__falloutCtrl.onSettingsChanged += self._updateFalloutSettings
self.__multiselectionMode = self.__falloutCtrl.isSelected()
self.__setFilters()
self.__updateMultiselectionData()
def run(self):
self.isRunning = True
if not self.isSubscribed:
self.isSubscribed = True
self.startGlobalListening()
g_eventBus.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
g_currentVehicle.onChanged += self.__onVehicleChanged
falloutCtrl = getFalloutCtrl()
falloutCtrl.onVehiclesChanged += self.__updateFalloutSettings
falloutCtrl.onSettingsChanged += self.__updateFalloutSettings
g_eventsCache.onSyncCompleted += self.__onEventsCacheResync
game_control.g_instance.igr.onIgrTypeChanged -= self.__onIGRChanged
self.toggle(isOn=self.isOn())
def _populate(self):
super(TankCarousel, self)._populate()
if self.__updateVehiclesTimerId is not None:
BigWorld.cancelCallback(self.__updateVehiclesTimerId)
self.__updateVehiclesTimerId = None
g_gameCtrl.rentals.onRentChangeNotify += self._updateRent
g_gameCtrl.igr.onIgrTypeChanged += self._updateIgrType
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onVehiclesChanged += self._updateFalloutSettings
self.__falloutCtrl.onSettingsChanged += self._updateFalloutSettings
self.__multiselectionMode = self.__falloutCtrl.isSelected()
self.__setFilters()
self.__updateMultiselectionData()
def doAction(self, action=None, dispatcher=None):
result = False
if action is not None:
actionName = action.actionName or _PAN.UNDEFINED
if actionName in (_PAN.JOIN_RANDOM_QUEUE, _PAN.UNDEFINED
) and getFalloutCtrl().isSelected():
actionName = _PAN.JOIN_EVENT_BATTLES_QUEUE
if actionName in self.CREATE_QUEUE_BY_ACTION:
queueType, doAction = self.CREATE_QUEUE_BY_ACTION[actionName]
g_prbCtrlEvents.onPreQueueFunctionalCreated(
queueType, doAction, action)
result = True
return result
def run(self):
self.isRunning = True
if not self.isSubscribed:
self.isSubscribed = True
self.startGlobalListening()
g_eventBus.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
g_currentVehicle.onChanged += self.__onVehicleChanged
falloutCtrl = getFalloutCtrl()
falloutCtrl.onVehiclesChanged += self.__updateFalloutSettings
falloutCtrl.onSettingsChanged += self.__updateFalloutSettings
g_eventsCache.onSyncCompleted += self.__onEventsCacheResync
game_control.g_instance.igr.onIgrTypeChanged -= self.__onIGRChanged
self.toggle(isOn=self.isOn())
def _populate(self):
self.__updateHangarMenuData()
battle_selector_items.create()
super(LobbyHeader, self)._populate()
self.startGlobalListening()
self.app.containerManager.onViewAddedToContainer += self.__onViewAddedToContainer
game_control.g_instance.wallet.onWalletStatusChanged += self.__onWalletChanged
game_control.g_instance.gameSession.onPremiumNotify += self.__onPremiumTimeChanged
game_control.g_instance.igr.onIgrTypeChanged += self.__onIGRChanged
g_lobbyContext.getServerSettings().onServerSettingsChange += self.__onServerSettingChanged
g_currentVehicle.onChanged += self.__onVehicleChanged
g_currentPreviewVehicle.onChanged += self.__onVehicleChanged
g_eventsCache.onSyncCompleted += self.__onEventsCacheResync
g_itemsCache.onSyncCompleted += self.__onItemsChanged
game_control.g_instance.boosters.onBoosterChangeNotify += self.__onUpdateGoodies
self.__falloutCtrl = getFalloutCtrl()
self.__falloutCtrl.onVehiclesChanged += self.__updateFalloutSettings
self.__falloutCtrl.onSettingsChanged += self.__updateFalloutSettings
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self.__handleFightButtonUpdated, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.CoolDownEvent.PREBATTLE, self.__handleSetPrebattleCoolDown, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.BubbleTooltipEvent.SHOW, self.__showBubbleTooltip, scope=EVENT_BUS_SCOPE.LOBBY)
self.addListener(events.CloseWindowEvent.GOLD_FISH_CLOSED, self.__onGoldFishWindowClosed, scope=EVENT_BUS_SCOPE.LOBBY)
g_clientUpdateManager.addCallbacks({'stats.credits': self.__setCredits,
'stats.gold': self.__setGold,
'stats.freeXP': self.__setFreeXP,
'stats.clanInfo': self.__setClanInfo,
'goodies': self.__updateGoodies,
'account.premiumExpiryTime': self.__onPremiumExpireTimeChanged,
'cache.SPA': self.__onSPAUpdated})
self.as_setFightButtonS(i18n.makeString('#menu:headerButtons/battle'))
self.as_setWalletStatusS(game_control.g_instance.wallet.componentsStatuses)
self.as_setPremShopDataS(RES_ICONS.MAPS_ICONS_LOBBY_ICON_PREMSHOP, MENU.HEADERBUTTONS_BTNLABEL_PREMSHOP, TOOLTIPS.HEADER_PREMSHOP, TOOLTIP_TYPES.COMPLEX)
self.as_initOnlineCounterS(constants.IS_SHOW_SERVER_STATS)
if constants.IS_SHOW_SERVER_STATS:
game_control.g_instance.serverStats.onStatsReceived += self.__onStatsReceived
self.__onStatsReceived()
self.updateAccountInfo()
self.__updateServerData()
if not isTimeToShowGoldFishPromo():
enabledVal = isGoldFishActionActive()
tooltip = TOOLTIPS.HEADER_REFILL_ACTION if enabledVal else TOOLTIPS.HEADER_REFILL
self.as_setGoldFishEnabledS(enabledVal, False, tooltip, TOOLTIP_TYPES.COMPLEX)
g_preDefinedHosts.onPingPerformed += self.__onPingPerformed
g_preDefinedHosts.requestPing()
g_settingsCore.onSettingsChanged += self.__onSettingsChanged
encyclopediaController = game_control.getEncyclopediaController()
encyclopediaController.onNewRecommendationReceived += self.__onNewEncyclopediaRecommendation
encyclopediaController.onStateChanged += self.__updateHangarMenuData
Waiting.hide('enter')
def check(self, teamLimits):
if not g_currentVehicle.isPresent():
return (False, PREBATTLE_RESTRICTION.VEHICLE_NOT_PRESENT)
if g_currentVehicle.isEvent():
return (False, PREBATTLE_RESTRICTION.VEHICLE_NOT_SUPPORTED)
if g_currentVehicle.isFalloutOnly() and not getFalloutCtrl().isSelected():
return (False, PREBATTLE_RESTRICTION.VEHICLE_FALLOUT_ONLY)
if not g_currentVehicle.isReadyToFight():
return (False, PREBATTLE_RESTRICTION.VEHICLE_NOT_READY)
vehicle = g_currentVehicle.item
shellsList = []
for shell in vehicle.shells:
shellsList.extend([shell.intCD, shell.count])
return isVehicleValid(vehicle.descriptor, shellsList, teamLimits)
def __getVehicleStatus(self, showCustomStates, vehicle):
if showCustomStates:
isUnlocked = vehicle.isUnlocked
isInInventory = vehicle.isInInventory
money = g_itemsCache.items.stats.money
price = vehicle.minRentPrice or vehicle.buyPrice
needMoney = price - money
needMoney = needMoney.toNonNegative()
msg = None
level = Vehicle.VEHICLE_STATE_LEVEL.WARNING
if not isUnlocked:
msg = 'notUnlocked'
elif isInInventory:
msg = 'inHangar'
elif needMoney:
currency = needMoney.getCurrency(byWeight=False)
if currency == Currency.CREDITS:
msg = 'notEnoughCredits'
level = Vehicle.VEHICLE_STATE_LEVEL.CRITICAL
elif currency == Currency.GOLD:
msg = 'notEnoughGold'
level = Vehicle.VEHICLE_STATE_LEVEL.CRITICAL
else:
msg = 'notEnough'
level = Vehicle.VEHICLE_STATE_LEVEL.CRITICAL
LOG_WARNING('Unsupported currency: ', currency)
if msg is not None:
header, text = getComplexStatus('#tooltips:vehicleStatus/%s' % msg)
return {'header': header,
'text': text,
'level': level}
return
else:
state, level = vehicle.getState()
if state == Vehicle.VEHICLE_STATE.SERVER_RESTRICTION:
return
isSuitableVeh = getFalloutCtrl().isSuitableVeh(vehicle)
if not isSuitableVeh:
header, text = getComplexStatus('#tooltips:vehicleStatus/%s' % Vehicle.VEHICLE_STATE.NOT_SUITABLE)
level = Vehicle.VEHICLE_STATE_LEVEL.WARNING
else:
header, text = getComplexStatus('#tooltips:vehicleStatus/%s' % state)
if header is None and text is None:
return
return {'header': header,
'text': text,
'level': level}
def canPlayerDoAction(self):
canDo, restriction = self.__collection.canPlayerDoAction(False)
falloutCtrl = getFalloutCtrl()
if canDo:
if falloutCtrl.isEnabled():
if falloutCtrl.getBattleType(
) == FALLOUT_BATTLE_TYPE.UNDEFINED:
canDo = False
restriction = PREBATTLE_RESTRICTION.FALLOUT_NOT_SELECTED
elif not g_currentVehicle.isGroupReady():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_GROUP_IS_NOT_READY
elif not g_currentVehicle.isReadyToFight():
if not g_currentVehicle.isPresent():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_NOT_PRESENT
elif g_currentVehicle.isInBattle():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_BATTLE
elif not g_currentVehicle.isCrewFull():
canDo = False
restriction = PREBATTLE_RESTRICTION.CREW_NOT_FULL
elif g_currentVehicle.isBroken():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_BROKEN
elif g_currentVehicle.isFalloutOnly():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_FALLOUT_ONLY
elif g_currentVehicle.isDisabledInRoaming():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_ROAMING
elif g_currentVehicle.isDisabledInPremIGR():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_PREMIUM_IGR_ONLY
elif g_currentVehicle.isDisabledInRent():
unit = self.getUnitFunctional()
if unit is not None and unit.getFlags().isInPreArena():
canDo = True
else:
canDo = False
if g_currentVehicle.isPremiumIGR():
restriction = PREBATTLE_RESTRICTION.VEHICLE_IGR_RENTALS_IS_OVER
else:
restriction = PREBATTLE_RESTRICTION.VEHICLE_RENTALS_IS_OVER
if canDo:
canDo, restriction = self.__collection.canPlayerDoAction(True)
return (canDo, restriction)
def doAction(self, action = None, dispatcher = None):
result = False
def _leavePreQueue():
self.leave(pre_queue_ctx.LeavePreQueueCtx(waitingID='prebattle/leave'))
if not self.isInQueue():
def _joinResponse(success):
if not success:
_leavePreQueue()
falloutCtrl = getFalloutCtrl()
self.join(pre_queue_ctx.JoinEventBattlesQueueCtx(map(lambda v: v.invID, falloutCtrl.getSelectedVehicles()), falloutCtrl.getBattleType(), waitingID='prebattle/join'), callback=_joinResponse)
else:
_leavePreQueue()
return result
def canPlayerDoAction(self):
canDo, restriction = self.__collection.canPlayerDoAction(False)
falloutCtrl = getFalloutCtrl()
if canDo:
if falloutCtrl.isEnabled():
if falloutCtrl.getBattleType() == FALLOUT_BATTLE_TYPE.UNDEFINED:
canDo = False
restriction = PREBATTLE_RESTRICTION.FALLOUT_NOT_SELECTED
elif not g_currentVehicle.isGroupReady():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_GROUP_IS_NOT_READY
elif not g_currentVehicle.isReadyToFight():
if not g_currentVehicle.isPresent():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_NOT_PRESENT
elif g_currentVehicle.isInBattle():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_BATTLE
elif not g_currentVehicle.isCrewFull():
canDo = False
restriction = PREBATTLE_RESTRICTION.CREW_NOT_FULL
elif g_currentVehicle.isBroken():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_BROKEN
elif g_currentVehicle.isFalloutOnly():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_FALLOUT_ONLY
elif g_currentVehicle.isDisabledInRoaming():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_ROAMING
elif g_currentVehicle.isDisabledInPremIGR():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_PREMIUM_IGR_ONLY
elif g_currentVehicle.isDisabledInRent():
unit = self.getUnitFunctional()
if unit is not None and unit.getFlags().isInPreArena():
canDo = True
else:
canDo = False
if g_currentVehicle.isPremiumIGR():
restriction = PREBATTLE_RESTRICTION.VEHICLE_IGR_RENTALS_IS_OVER
else:
restriction = PREBATTLE_RESTRICTION.VEHICLE_RENTALS_IS_OVER
if canDo:
canDo, restriction = self.__collection.canPlayerDoAction(True)
return (canDo, restriction)
def _initializeFilters(self):
xpRate = 'x%d' % g_itemsCache.items.shop.dailyXPFactor
falloutBattleType = i18n.makeString(
'#menu:headerButtons/battle/menu/fallout/{0}'.format(
getFalloutCtrl().getBattleType()))
self.as_initCarouselFilterS({
'counterCloseTooltip':
makeTooltip(TOOLTIPS.TANKSFILTER_COUNTER_CLOSE_HEADER,
TOOLTIPS.TANKSFILTER_COUNTER_CLOSE_BODY),
'paramsFilter': {
'icon':
getButtonsAssetPath('params'),
'tooltip':
makeTooltip('#tank_carousel_filter:filter/paramsFilter/header',
'#tank_carousel_filter:filter/paramsFilter/body')
},
'favoriteFilter': {
'icon':
getButtonsAssetPath('favorite'),
'tooltip':
makeTooltip(
'#tank_carousel_filter:filter/favoriteFilter/header',
'#tank_carousel_filter:filter/favoriteFilter/body')
},
'gameModeFilter': {
'icon':
getButtonsAssetPath('game_mode'),
'tooltip':
makeTooltip(
'#tank_carousel_filter:filter/gameModeFilter/header',
i18n.makeString(
'#tank_carousel_filter:filter/gameModeFilter/body',
type=falloutBattleType))
},
'bonusFilter': {
'icon':
getButtonsAssetPath('bonus_%s' % xpRate),
'tooltip':
makeTooltip(
'#tank_carousel_filter:filter/bonusFilter/header',
i18n.makeString(
'#tank_carousel_filter:filter/bonusFilter/body',
bonus=xpRate))
}
})
def __updatePrebattleControls(self):
if not self.prbDispatcher:
return
else:
items = battle_selector_items.getItems()
state = self.prbDispatcher.getFunctionalState()
selected = items.update(state)
canDo, canDoMsg = self.prbDispatcher.canPlayerDoAction()
playerInfo = self.prbDispatcher.getPlayerInfo()
if selected.isInSquad(state):
isInSquad = True
else:
isInSquad = False
self.as_doDisableHeaderButtonS(self.BUTTONS.SQUAD, self.prbDispatcher.getFunctionalCollection().canCreateSquad())
falloutCtrl = getFalloutCtrl()
isFallout = falloutCtrl.isSelected()
if isInSquad:
tooltip = TOOLTIPS.HEADER_SQUAD_MEMBER
else:
tooltip = TOOLTIPS.HEADER_DOMINATIONSQUAD if isFallout else TOOLTIPS.HEADER_SQUAD
self.as_updateSquadS(isInSquad, tooltip, TOOLTIP_TYPES.COMPLEX)
isFightBtnDisabled = not canDo or selected.isFightButtonForcedDisabled()
if isFightBtnDisabled and not state.hasLockedState:
if state.isInPreQueue(queueType=constants.QUEUE_TYPE.SANDBOX) and canDoMsg == QUEUE_RESTRICTION.LIMIT_LEVEL:
self.as_setFightBtnTooltipS(self.__getSandboxTooltipData())
elif isFallout:
self.as_setFightBtnTooltipS(self.__getFightBtnTooltipData(canDoMsg))
else:
self.as_setFightBtnTooltipS(None)
else:
self.as_setFightBtnTooltipS(None)
self.as_disableFightButtonS(isFightBtnDisabled)
self.as_setFightButtonS(selected.getFightButtonLabel(state, playerInfo))
self.as_updateBattleTypeS(i18n.makeString(selected.getLabel()), selected.getSmallIcon(), selected.isSelectorBtnEnabled(), TOOLTIPS.HEADER_BATTLETYPE, TOOLTIP_TYPES.COMPLEX, selected.getData())
if selected.isDisabled():
self.__closeBattleTypeSelectPopover()
else:
self.__updateBattleTypeSelectPopover()
isNavigationEnabled = not state.isNavigationDisabled()
self.as_doDisableHeaderButtonS(self.BUTTONS.SILVER, isNavigationEnabled)
self.as_doDisableHeaderButtonS(self.BUTTONS.GOLD, isNavigationEnabled)
self.as_doDisableHeaderButtonS(self.BUTTONS.FREE_XP, isNavigationEnabled)
self.as_doDisableHeaderButtonS(self.BUTTONS.ACCOUNT, isNavigationEnabled)
self.updateAccountAttrs()
return
def isGroupReady(self):
from gui.game_control import getFalloutCtrl
falloutCtrl = getFalloutCtrl()
if not falloutCtrl.isSelected():
return (True, '')
selectedVehicles = falloutCtrl.getSelectedVehicles()
selectedVehiclesCount = len(selectedVehicles)
config = falloutCtrl.getConfig()
if findFirst(lambda v: v.level == config.vehicleLevelRequired, selectedVehicles) is None:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_REQUIRED)
if selectedVehiclesCount < config.minVehiclesPerPlayer:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_MIN)
if selectedVehiclesCount > config.maxVehiclesPerPlayer:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_MAX)
for v in falloutCtrl.getSelectedVehicles():
if v.isBroken or not v.isCrewFull or v.isInBattle or v.rentalIsOver:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_BROKEN)
return (True, '')
def getHangarMessage(self):
if not self.isPresent():
return (Vehicle.VEHICLE_STATE.NOT_PRESENT, MENU.CURRENTVEHICLESTATUS_NOTPRESENT, Vehicle.VEHICLE_STATE_LEVEL.CRITICAL)
state, stateLvl = self.item.getState()
if state == Vehicle.VEHICLE_STATE.IN_PREMIUM_IGR_ONLY:
icon = icons.premiumIgrBig()
if self.item.isRented:
rentLeftStr = getTimeLeftStr('#menu:vehicle/igrRentLeft/%s', self.item.rentInfo.getTimeLeft())
message = i18n.makeString('#menu:currentVehicleStatus/' + state, icon=icon, time=rentLeftStr)
else:
message = i18n.makeString('#menu:tankCarousel/vehicleStates/inPremiumIgrOnly', icon=icon)
return (state, message, stateLvl)
falloutCtrl = getFalloutCtrl()
if falloutCtrl and falloutCtrl.isSelected():
if not self.item.isFalloutAvailable or self.item.getCustomState() == Vehicle.VEHICLE_STATE.UNSUITABLE_TO_QUEUE:
message = i18n.makeString('#menu:tankCarousel/vehicleStates/%s' % Vehicle.VEHICLE_STATE.NOT_SUITABLE)
return (state, message, Vehicle.VEHICLE_STATE_LEVEL.WARNING)
message = '#menu:currentVehicleStatus/' + state
return (state, message, stateLvl)
def isGroupReady(self):
from gui.game_control import getFalloutCtrl
falloutCtrl = getFalloutCtrl()
if not falloutCtrl.isSelected():
return (True, '')
selectedVehicles = falloutCtrl.getSelectedVehicles()
selectedVehiclesCount = len(selectedVehicles)
config = falloutCtrl.getConfig()
if falloutCtrl.mustSelectRequiredVehicle():
return (False, Vehicle.VEHICLE_STATE.FALLOUT_REQUIRED)
if selectedVehiclesCount < config.minVehiclesPerPlayer:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_MIN)
if selectedVehiclesCount > config.maxVehiclesPerPlayer:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_MAX)
for v in selectedVehicles:
if v.isBroken or not v.isCrewFull or v.isInBattle or v.rentalIsOver or v.isDisabledInPremIGR:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_BROKEN)
return (True, '')
def isGroupReady(self):
from gui.game_control import getFalloutCtrl
falloutCtrl = getFalloutCtrl()
if not falloutCtrl.isSelected():
return (True, '')
selectedVehicles = falloutCtrl.getSelectedVehicles()
selectedVehiclesCount = len(selectedVehicles)
config = falloutCtrl.getConfig()
if falloutCtrl.mustSelectRequiredVehicle():
return (False, Vehicle.VEHICLE_STATE.FALLOUT_REQUIRED)
if selectedVehiclesCount < config.minVehiclesPerPlayer:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_MIN)
if selectedVehiclesCount > config.maxVehiclesPerPlayer:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_MAX)
for v in selectedVehicles:
if v.isBroken or not v.isCrewFull or v.isInBattle or v.rentalIsOver or v.isDisabledInPremIGR:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_BROKEN)
return (True, '')
def canPlayerDoAction(self):
canDo, restriction = self.__collection.canPlayerDoAction(False)
if canDo:
if g_currentPreviewVehicle.isPresent():
canDo = False
restriction = PREBATTLE_RESTRICTION.PREVIEW_VEHICLE_IS_PRESENT
elif not g_currentVehicle.isReadyToFight():
if not g_currentVehicle.isPresent():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_NOT_PRESENT
elif g_currentVehicle.isInBattle():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_BATTLE
elif not g_currentVehicle.isCrewFull():
canDo = False
restriction = PREBATTLE_RESTRICTION.CREW_NOT_FULL
elif g_currentVehicle.isBroken():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_BROKEN
elif g_currentVehicle.isFalloutOnly(
) and not game_control.getFalloutCtrl().isSelected():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_FALLOUT_ONLY
elif g_currentVehicle.isDisabledInRoaming():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_ROAMING
elif g_currentVehicle.isDisabledInPremIGR():
canDo = False
restriction = PREBATTLE_RESTRICTION.VEHICLE_IN_PREMIUM_IGR_ONLY
elif g_currentVehicle.isDisabledInRent():
unit = self.getUnitFunctional()
if unit is not None and unit.getFlags().isInPreArena():
canDo = True
else:
canDo = False
if g_currentVehicle.isPremiumIGR():
restriction = PREBATTLE_RESTRICTION.VEHICLE_IGR_RENTALS_IS_OVER
else:
restriction = PREBATTLE_RESTRICTION.VEHICLE_RENTALS_IS_OVER
if canDo:
canDo, restriction = self.__collection.canPlayerDoAction(True)
return (canDo, restriction)
def isGroupReady(self):
from gui.game_control import getFalloutCtrl
falloutCtrl = getFalloutCtrl()
if not falloutCtrl.isSelected():
return (True, '')
selectedVehicles = falloutCtrl.getSelectedVehicles()
selectedVehiclesCount = len(selectedVehicles)
config = falloutCtrl.getConfig()
if findFirst(lambda v: v.level == config.vehicleLevelRequired,
selectedVehicles) is None:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_REQUIRED)
if selectedVehiclesCount < config.minVehiclesPerPlayer:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_MIN)
if selectedVehiclesCount > config.maxVehiclesPerPlayer:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_MAX)
for v in falloutCtrl.getSelectedVehicles():
if v.isBroken or not v.isCrewFull or v.isInBattle or v.rentalIsOver:
return (False, Vehicle.VEHICLE_STATE.FALLOUT_BROKEN)
return (True, '')
def validateVehicles(self, vInfos, flags):
if not findFirst(lambda v: not v.isEmpty(), vInfos, False):
return (False, UNIT_RESTRICTION.VEHICLE_NOT_SELECTED)
else:
for vInfo in vInfos:
vehicle = vInfo.getVehicle()
if vehicle is not None:
if vehicle.isEvent != self._useEventVehicles:
return (False, UNIT_RESTRICTION.VEHICLE_WRONG_MODE)
if not vehicle.isReadyToPrebattle(checkForRent=not flags.isInPreArena()):
if vehicle.isBroken:
return (False, UNIT_RESTRICTION.VEHICLE_BROKEN)
if not vehicle.isCrewFull:
return (False, UNIT_RESTRICTION.VEHICLE_CREW_NOT_FULL)
if not flags.isInPreArena() and vehicle.rentalIsOver:
return (False, UNIT_RESTRICTION.VEHICLE_RENT_IS_OVER)
if vehicle.isInBattle:
return (False, UNIT_RESTRICTION.VEHICLE_IS_IN_BATTLE)
if vehicle.isFalloutOnly() and not getFalloutCtrl().isSelected():
return (False, UNIT_RESTRICTION.VEHICLE_WRONG_MODE)
return (False, UNIT_RESTRICTION.VEHICLE_NOT_VALID)
return (True, UNIT_RESTRICTION.UNDEFINED)
def __updateClientState(self):
dispatcher = g_prbLoader.getDispatcher()
queueType = None
if dispatcher is not None:
queueType = dispatcher.getPreQueueFunctional().getEntityType()
permissions = dispatcher.getUnitFunctional().getPermissions()
if permissions and not permissions.canExitFromQueue():
self.as_showExitS(False)
postFix = ''
if self.__isInEventBattles():
queueType = constants.ARENA_GUI_TYPE.EVENT_BATTLES
battleType = getFalloutCtrl().getBattleType()
if battleType == constants.FALLOUT_BATTLE_TYPE.MULTITEAM:
postFix = '/multiteam'
guiType = prb_getters.getArenaGUIType(queueType=queueType)
title = '#menu:loading/battleTypes/%d%s' % (guiType, postFix)
description = '#menu:loading/battleTypes/desc/%d%s' % (guiType,
postFix)
if guiType != constants.ARENA_GUI_TYPE.UNKNOWN and guiType in constants.ARENA_GUI_TYPE_LABEL.LABELS:
iconlabel = constants.ARENA_GUI_TYPE_LABEL.LABELS[guiType]
else:
iconlabel = 'neutral'
self.as_setTypeInfoS(iconlabel, title, description)
return
def _getFalloutVehLevelStr(self):
config = getFalloutCtrl().getConfig()
requiredLevelStr = int2roman(config.vehicleLevelRequired)
return (CYBERSPORT.WINDOW_UNIT_MESSAGE_FALLOUTLEVEL, {
'level': requiredLevelStr
})
