def _updatePlayerPlaneScoresData(self):
avatarInfo = self._clientArena.avatarInfos[self._bigWorld.player().id]
economics = avatarInfo['economics']
planeTypeRanks = avatarInfo['planeTypeRank']
pointsByPlanes = economics['pointsByPlanes']
if not pointsByPlanes:
globalID = avatarInfo['airplaneInfo']['globalID']
planeID = self._planesConfigurationsDB.getAirplaneConfiguration(
globalID).planeID
pointsByPlanes = [(planeID, 0)]
for planeID, battlePoints in pointsByPlanes:
planeData = self._db.getAircraftData(planeID)
planeType = planeData.airplane.planeType
scoreItem = self._model.planeScoresData.first(
lambda e: e.planeID.get() == planeID)
if scoreItem:
scoreItem.battlePoints = battlePoints
scoreItem.rankID = planeTypeRanks[planeType]
else:
self._model.planeScoresData.append(
planeID=planeID,
planeType=planeType,
planeName=localizeAirplane(planeData.airplane.name),
battlePoints=battlePoints,
rankID=planeTypeRanks[planeType])
def getLobbyAirplane(aircraftID):
aircraftID = int(aircraftID)
airplaneData = db.DBLogic.g_instance.getAircraftData(aircraftID)
if airplaneData is None:
LOG_ERROR('updateCarouselResponse. plane is wrong. Airplane = ', aircraftID)
return
else:
nationID = db.DBLogic.g_instance.getNationIDbyAircraftID(aircraftID)
airplane = LobbyAirplane()
import BWPersonality
inv = BWPersonality.g_lobbyCarouselHelper.inventory
try:
airplane.nationID = nationID
airplane.planeID = aircraftID
airplane.name = localizeAirplane(airplaneData.airplane.name)
airplane.longName = localizeAirplaneLong(airplaneData.airplane.name)
if airplaneData.airplane.options.isDev:
airplane.longName += ' (Dev)'
airplane.hudIconPath = airplaneData.airplane.hudIcoPath if airplaneData.airplane else 'n/a'
airplane.planeIconPath = airplaneData.airplane.iconPath if airplaneData.airplane else 'n/a'
airplane.previewIconPath = airplaneData.airplane.previewIconPath if airplaneData.airplane else 'n/a'
airplane.nationFlagPath = db.DBLogic.g_instance.getAircraftFlagPath(airplaneData.airplane.name)
airplane.level = airplaneData.airplane.level if airplaneData.airplane else 0
airplane.levelRomanNum = airplane.level
airplane.mass = 0.0
airplane.hitPoints = 0.0
airplane.type = localizeLobby(PREBATTLE_PLANE_TYPE_NAME[airplaneData.airplane.planeType])
airplane.isPremium = db.DBLogic.g_instance.isPlanePremium(aircraftID)
airplane.isElite = inv.isAircraftElite(aircraftID)
airplane.experience = inv.getAircraftExp(aircraftID)
airplane.planeType = airplaneData.airplane.planeType
airplane.isResearched = inv.isAircraftOpened(aircraftID)
airplane.isBought = inv.isAircraftBought(aircraftID)
airplane.updatePrice()
airplane.researchExp = 0
upgrade = db.DBLogic.g_instance.upgrades.get(airplaneData.airplane.name, None)
if upgrade is not None and upgrade.variant[0].parentUpgrade:
airplane.researchExp = int(upgrade.variant[0].parentUpgrade[0].experience)
planeStatus = airplane.isPremium * PLANE_CLASS.PREMIUM or airplane.isElite * PLANE_CLASS.ELITE or PLANE_CLASS.REGULAR
airplane.planeTypeIconPath = PLANE_TYPE_ICO_PATH.icon(airplane.planeType, planeStatus)
upgradesList, aircraftList = db.DBLogic.g_instance.getAircraftUpgrades(aircraftID)
defaultConfiguration = _airplanesConfigurations_db.getDefaultAirplaneConfiguration(aircraftID)
upgradeInfoMaps = []
for upgrade in upgradesList:
info = inv.getUpgradeInfoMap(aircraftID, upgrade)
info['isInstalled'] = any((m == upgrade.name for m in defaultConfiguration.modules))
upgradeInfoMaps.append(info)
airplane.modules = LobbyAirplaneModules(aircraftID, upgradeInfoMaps)
airplane.weapons = LobbyAirplaneWeapons(aircraftID, None, list(defaultConfiguration.weaponSlots))
from gui.Scaleform.LobbyAirplanePresets import LobbyAirplanePresets
airplane.presets = LobbyAirplanePresets(aircraftID, airplane.modules, airplane.weapons, None, [ preset.name for preset in db.DBLogic.g_instance.getAircraftPresetsListByName(airplaneData.airplane.name) ], db.DBLogic.g_instance.getAircraftDefaultPresetFromName(airplaneData.airplane.name).name)
airplane.presets.fillPresets()
except:
LOG_CURRENT_EXCEPTION()
return
from Account import PLANE_BLOCK_TYPE
airplane.blockType = PLANE_BLOCK_TYPE.get(airplane.planeID, BLOCK_TYPE.UNLOCKED)
return airplane
def __sortAvatars(self):
teams = dict()
for avatarInfo in self.avatarInfos.values():
level = avatarInfo['settings'].airplane.level
teamIndex = avatarInfo['teamIndex']
name = localizeAirplane(avatarInfo['settings'].airplane.name)
if teamIndex not in teams:
teams[teamIndex] = dict()
if level not in teams[teamIndex]:
teams[teamIndex][level] = dict()
if name not in teams[teamIndex][level]:
teams[teamIndex][level][name] = list()
teams[teamIndex][level][name].append(avatarInfo)
sortedList = list()
for team in teams.values():
for level in team.values():
for name in level.values():
name.sort(key=lambda avatarInfo: avatarInfo['playerName'])
sortedLevelsList = sorted(team.keys(), None, None, True)
for levelID in sortedLevelsList:
sortedPlaneNameList = sorted(team[levelID].keys())
for planeName in sortedPlaneNameList:
sortedList.extend(team[levelID][planeName])
for avatarInfo in sortedList:
if avatarInfo['teamIndex'] not in self.__sortedAvatarsIDs:
self.__sortedAvatarsIDs[avatarInfo['teamIndex']] = list()
self.__sortedAvatarsIDs[avatarInfo['teamIndex']].append(
avatarInfo['avatarID'])
return
def _updatePlaneIfChanged(self, entity, avatarModel):
settings = entity.settings
newPlaneName = localizeAirplane(settings.airplane.name)
if newPlaneName != avatarModel.planeName.get():
avatarModel.planeName = newPlaneName
avatarModel.planeType = settings.airplane.planeType
avatarModel.planeLevel = settings.airplane.level
def _updatePlaneScoresData(self, avatarID, *args, **kwargs):
"""Update score data for all avatar planes.
Is called when avatar rank is changed and when new battle points received from server
"""
avatarInfo = self._clientArena.avatarInfos[avatarID]
economics = avatarInfo['economics']
planeTypeRanks = avatarInfo['planeTypeRank']
pointsByPlanes = economics['pointsByPlanes']
if not pointsByPlanes:
globalID = avatarInfo['airplaneInfo']['globalID']
planeID = self._planeConfigurationsDB.getAirplaneConfiguration(
globalID).planeID
pointsByPlanes = [(planeID, 0)]
avatarItem = self._model.avatars.first(
lambda e: e.id.get() == avatarID)
if not avatarItem:
return
for planeID, battlePoints in pointsByPlanes:
planeData = self._db.getAircraftData(planeID)
planeType = planeData.airplane.planeType
scoreItem = avatarItem.planeScoresData.first(
lambda e: e.planeID.get() == planeID)
if scoreItem:
scoreItem.battlePoints = battlePoints
scoreItem.rankID = planeTypeRanks[planeType]
else:
avatarItem.planeScoresData.append(
planeID=planeID,
planeType=planeType,
planeName=localizeAirplane(planeData.airplane.name),
battlePoints=battlePoints,
rankID=planeTypeRanks[planeType])
def convertMessage(message, players, senderInfo, targetID):
if not message or message[0] == '!':
return message
else:
message = localizeBotChat(message)
if not message:
return ''
lastPlayerName = ''
botName = ''
planeName = ''
team = senderInfo['teamIndex']
isAlive = lambda e: e['stats']['flags'] & AvatarFlags.DEAD == 0
targetInfo = players.get(targetID, None)
if targetInfo:
localPlaneName = localizeAirplane(
targetInfo['settings'].airplane.name)
botName = targetInfo['playerName']
planeName = localPlaneName
allPlayers = []
aliveAllyPlayers = []
for id_, player in players.iteritems():
if player['classID'] == EntitySupportedClasses.AvatarBot:
continue
allPlayers.append(player)
if player['teamIndex'] == team and isAlive(player):
aliveAllyPlayers.append(player)
randomPlayerName = random.choice(allPlayers)['playerName']
if len(aliveAllyPlayers) > 0:
lastPlayerName = random.choice(aliveAllyPlayers)['playerName']
result = message.format(bot_name=botName,
plane_name=planeName,
random_player_name=randomPlayerName,
last_player_name=lastPlayerName)
return result
def __call__(self, account, ob, **kw):
adaptedOb = super(IPlaneDescriptionAdapter,
self).__call__(account, ob, **kw)
if ob is None:
return adaptedOb
else:
if ob.description:
adaptedOb['description'] = localizeAirplaneAny(
ob.description.textDescription)
dbInstance = db.DBLogic.g_instance
adaptedOb['presetsList'] = airplanesConfigurationsList[ob.id]
adaptedOb['defaultPreset'] = airplanesDefaultConfigurations[ob.id]
adaptedOb['level'] = ob.level
adaptedOb['icoPath'] = ob.iconPath
adaptedOb['bigIcoPath'] = ob.previewIconPath
adaptedOb['hudIcoPath'] = ob.hudIcoPath
adaptedOb['treeIcoPath'] = ob.treeIconPath
adaptedOb[
'battleLoadingIcoPath'] = ob.battleLoadingIconPath if hasattr(
ob, 'battleLoadingIconPath') else ob.previewIconPath
adaptedOb['middleName'] = localizeAirplaneMid(ob.name)
adaptedOb['name'] = localizeAirplane(ob.name)
adaptedOb['longName'] = localizeAirplaneLong(ob.name)
adaptedOb['isExclusive'] = dbInstance.isPlaneExclusive(ob.id)
adaptedOb['isTest'] = getattr(ob.options, 'isTest', False)
if hasattr(ob, 'tags'):
adaptedOb['tagsList'] = [[localizeTooltips(x.name), x.type]
for x in ob.tags.tag]
else:
adaptedOb['tagsList'] = []
return adaptedOb
def _requestPlaneData(self, planeID):
data = self._db.getAircraftData(planeID).airplane
isPremium = self._db.isPlanePremium(planeID)
isElite = planeID in self._playerAvatar.elitePlanes
planeStatus = PLANE_CLASS.PREMIUM if isPremium else isElite * PLANE_CLASS.ELITE or PLANE_CLASS.REGULAR
self._model.planes.append(
planeID=planeID,
planeNameShort=localizeAirplane(data.name),
planeLevel=data.level,
prevIconPath=data.iconPath,
planeType=data.planeType,
nation=self._db.getNationIDbyName(data.country),
planeStatus=planeStatus,
typeIconPath=PLANE_TYPE_ICO_PATH.iconHud(data.planeType,
planeStatus))
LOG_DEBUG(' TEST PLANE DATA: _requestPlaneData: ', planeID,
localizeAirplane(data.name))
def __getResearchAircraftVOfromMap(self, aircraftsDataMap):
airplaneID = aircraftsDataMap['id']
airplaneData = db.DBLogic.g_instance.getAircraftData(airplaneID)
if airplaneData is None:
LOG_ERROR('ResearchTreeHelper::__getResearchAircraftVOfromMap. plane is wrong. Airplane = ', airplaneID)
return
else:
shortName = localizeAirplane(airplaneData.airplane.name)
longName = localizeAirplaneLong(airplaneData.airplane.name)
if airplaneData.airplane.options.isDev:
longName = ''.join([longName, ' (Dev)'])
shortName = ''.join([shortName, ' (Dev)'])
parentIDs = []
requiredResearches = dict()
if not (self.__lobbyCarouselHelper.inventory.isAircraftOpened(airplaneID) or db.DBLogic.g_instance.isPlanePremium(airplaneID)):
from LobbyModulesTreeHelper import ResearchVO
def getUpgradeGroupName(planeID, upgrade):
if upgrade.type in UPGRADE_TYPE.MODULES:
return localizeComponents(UPGRADE_TYPE.DESCRIPTION_MAP[upgrade.type])
if upgrade.type in UPGRADE_TYPE.WEAPON:
return localizeLobby('AMMO_SLOT_' + db.DBLogic.g_instance.getSlotsWeaponUpgrade(planeID, upgrade)[0].name)
db_upgrades = db.DBLogic.g_instance.upgrades
for parentPlaneID, toResearch, _ in self.__lobbyCarouselHelper.inventory.calculateRequiredUpgradesForAircraft(airplaneID, None, onlyResearched=False):
parentIDs.append(parentPlaneID)
needResources = self.__lobbyCarouselHelper.inventory.calculateRequiredResourcesForUpgradePresset(parentPlaneID, toResearch, [])
requiredResearches[parentPlaneID] = [ ResearchVO(localizeUpgrade(db_upgrades[u]), getUpgradeGroupName(parentPlaneID, db_upgrades[u]), needResources[u]['exp']) for u in toResearch ]
isPremium = aircraftsDataMap['isPremium']
isElite = aircraftsDataMap['isElite']
planeStatus = isPremium * PLANE_CLASS.PREMIUM or isElite * PLANE_CLASS.ELITE or PLANE_CLASS.REGULAR
researchAircraftVO = ResearchAircraftVO()
researchAircraftVO.id = airplaneID
researchAircraftVO.longName = longName
researchAircraftVO.shortName = shortName
researchAircraftVO.icoTypePath = PLANE_TYPE_ICO_PATH.icon(airplaneData.airplane.planeType, planeStatus)
researchAircraftVO.icoPath = airplaneData.airplane.treeIconPath if airplaneData.airplane else 'n/a'
researchAircraftVO.isResearched = aircraftsDataMap['isResearched'] or isPremium
researchAircraftVO.isResearchAvailable = aircraftsDataMap['isResearchAvailable'] or isPremium
researchAircraftVO.isBought = aircraftsDataMap['isBought']
researchAircraftVO.isElite = aircraftsDataMap['isElite']
researchAircraftVO.isPremium = isPremium
researchAircraftVO.reqiuredExperience = aircraftsDataMap['reqiuredExperience']
researchAircraftVO.reqiuredExperiencePlane = aircraftsDataMap['reqiuredExperiencePlane']
researchAircraftVO.gotExperience = aircraftsDataMap['gotExperience']
researchAircraftVO.priceCredits = aircraftsDataMap['priceCredits']
researchAircraftVO.priceGold = aircraftsDataMap['priceGold']
researchAircraftVO.researchedParentID = aircraftsDataMap['researchedParentID']
researchAircraftVO.level = airplaneData.airplane.level
researchAircraftVO.parentName = aircraftsDataMap['parent']
researchAircraftVO.parentIDs = parentIDs
researchAircraftVO.blockType = aircraftsDataMap['blockType']
researchAircraftVO.sellPrice = aircraftsDataMap['sellPrice']
researchAircraftVO.requiredResearches = requiredResearches
return researchAircraftVO
def __convertAirplaneIdToVO(self, planeID):
botVO = BotVO()
botVO.planeID = planeID
planeSettings = db.DBLogic.g_instance.getAircraftData(planeID).airplane
botVO.planeLevel = planeSettings.level
botVO.planeType = planeSettings.planeType
botVO.planeName = localizeAirplane(planeSettings.name)
botVO.planeIcoPath = planeSettings.hudIcoPath
botVO.planeTypeIcoPath = getHudPlaneIcon(planeSettings.planeType)
return botVO
def _onNewBomber(self, id, avatarInfo):
LOG_DEBUG('EntitySource :: _onNewBomber', id)
settings = avatarInfo.get('settings')
return self._model.bombers.append(
id=id,
planeName=localizeAirplane(settings.airplane.name),
playerName=avatarInfo['playerName'],
teamIndex=getClientTeamIndex(avatarInfo['teamIndex'],
self._playerAvatar.teamIndex),
maxHealth=int(ceil(avatarInfo['maxHealth'])),
inWorld=False)
def __init__(self, aircraftID, freeExp, isPremium, isElite):
airplaneData = db.DBLogic.g_instance.getAircraftData(aircraftID)
self.aircraftID = aircraftID
self.planeName = localizeAirplane(airplaneData.airplane.name)
self.planeIcoPath = airplaneData.airplane.iconPath if airplaneData.airplane else 'n/a'
self.planeType = airplaneData.airplane.planeType
self.freeExp = freeExp
self.isElite = isElite
self.isPremium = isPremium
planeStatus = self.isPremium * PLANE_CLASS.PREMIUM or self.isElite * PLANE_CLASS.ELITE or PLANE_CLASS.REGULAR
self.planeTypeIcoPath = PLANE_TYPE_ICO_PATH.icon(self.planeType, planeStatus)
def _fillPlaneData(self, *args, **kwargs):
avatarInfo = self._clientArena.getAvatarInfo(self._playerAvatar.id)
settings = avatarInfo['settings']
self._model.planeName = localizeAirplane(settings.airplane.name)
self._model.planeLevel = settings.airplane.level
self._model.planeGlobalID = self._playerAvatar.globalID
self._model.id = self._playerAvatar.id
self._model.planeType = settings.airplane.planeType
self._model.teamIndex = self._playerAvatar.teamIndex
if self._clientArena.isAllServerDataReceived():
self._updatePlaneTypeRank()
def __showTextMessage(self,
senderID,
msgType,
messageStringID,
targetID,
message,
isHistory,
leaderType=-1,
isHTML=False):
messageT = ChatMessageVO()
messageT.msgType = msgType
messageT.senderID = senderID
messageT.message = message
messageT.isHistory = isHistory
messageT.leaderType = leaderType
owner = BigWorld.player()
clientArena = GameEnvironment.getClientArena()
if owner and clientArena:
avatarInfo = clientArena.getAvatarInfo(senderID)
if avatarInfo:
messageT.authorType = avatarInfo['settings'].airplane.planeType
messageT.authorName = avatarInfo['playerName']
messageT.vechicleName = localizeAirplane(
avatarInfo['settings'].airplane.name)
if avatarInfo['classID'] == EntitySupportedClasses.AvatarBot:
messageT.authorName = messageT.authorName.replace(
'>', '>').replace('<', '<')
messageT.authorClanAbbrev = avatarInfo['clanAbbrev']
if avatarInfo['teamIndex'] == BigWorld.player().teamIndex:
squadType = SQUAD_TYPES().getSquadType(
SQUAD_TYPES().getSquadIDbyAvatarID(senderID), senderID)
if squadType == SQUAD_TYPES.OWN:
messageT.teamType = TEAM_TYPE.BATTLE_SQUAD
else:
messageT.teamType = TEAM_TYPE.BATTLE_ALLY
else:
messageT.teamType = TEAM_TYPE.BATTLE_OPPONENT
else:
LOG_DEBUG('showTextMessage - avatarInfo is None', senderID,
msgType, messageStringID, targetID, message,
isHistory, leaderType)
messageT.isOwner = messageT.senderID == owner.id
if messageT.isOwner:
messageT.authorName = localizeHUD('HUD_YOU_MESSAGE')
messageT.authorClanAbbrev = ''
if messageT.message and not isHTML:
messageT.message = messageT.message.replace('>',
'>').replace(
'<', '<')
if messageT.senderID == self.__lastMessage.senderID and messageT.msgType == self.__lastMessage.msgType and messageT.message == self.__lastMessage.message and messageT.time - self.__lastMessage.time < MESSAGE_SAME_COOLDOWN:
return
self.__addChatMessage(messageT)
self.__lastMessage = messageT
def _fillPlaneData(self, *args, **kwargs):
avatarInfo = self._clientArena.getAvatarInfo(self._playerAvatar.id)
playerGlobalID = self._playerAvatar.globalID
settings = avatarInfo['settings']
self._updateModelShootingDistance()
self._model.planeName = localizeAirplane(settings.airplane.name)
self._model.planeLevel = settings.airplane.level
self._model.planeGlobalID = playerGlobalID
self._model.planeType = settings.airplane.planeType
self._model.planeTypeName = PREBATTLE_PLANE_TYPE_NAME[
settings.airplane.planeType]
self._model.planePreviewIcon = settings.airplane.previewIconPath
self._model.planeId = self._playerAvatar.objTypeID
self._model.planeStatus = self._getPlaneStatus()
self._model.teamIndex = self._playerAvatar.teamIndex
self._model.isReconnected = bool(self._playerAvatar.reconnected)
def __convertAccountMapToVO(self, accountMap, responseTime):
accountVO = AccountVO()
accountVO.id = accountMap['id']
accountVO.name = accountMap['name']
accountVO.clanAbbrev = accountMap['clanAbbrev']
accountVO.blockType = accountMap['blockType']
accountVO.status = accountMap['status']
accountVO.teamID = accountMap['teamID']
accountVO.isBot = accountMap['isBot']
accountVO.isMe = False if self.__entityID is None else accountMap[
'id'] == self.__entityID
accountVO.difficulty = accountMap['difficulty']
accountVO.difficultyIconPath = PREBATTLE_BOT_DIFFICULTY.ICON_PATH_MAP.get(
accountVO.difficulty, '')
if accountVO.isBot:
if accountMap['planeID'] != -1:
accountVO.name = getBotName(accountVO.name,
accountMap['planeID'], None)
else:
accountVO.name = getBotName(accountVO.name, None,
accountMap['planeCountry'])
selectedAirplane = self.__lobbyCarouselHelper.getCarouselAirplaneSelected(
)
currentPlaneID = selectedAirplane.planeID if selectedAirplane else -1
if accountVO.isMe and accountVO.teamID and accountMap['planeID'] != -1:
if accountMap['planeID'] != currentPlaneID:
BigWorld.callback(
1,
partial(self.__lobbyCarouselHelper.onSelectedPlaneID,
accountMap['planeID']))
self.__account.call_1('hangar.setSelectedAircraftID',
accountMap['planeID'])
accountVO.planeID = currentPlaneID if accountMap[
'planeID'] == -1 and accountVO.isMe else accountMap['planeID']
if accountVO.planeID != UNDEFINED_PLANE:
planeSettings = db.DBLogic.g_instance.getAircraftData(
accountVO.planeID).airplane
accountVO.planeLevel = planeSettings.level
accountVO.planeName = localizeAirplane(planeSettings.name)
accountVO.planeIcoPath = planeSettings.hudIcoPath
accountVO.planeTypeIcoPath = getHudPlaneIcon(
planeSettings.planeType)
accountVO.planeType = planeSettings.planeType
return accountVO
def setPlanes(self):
for planeID in self._playerAvatar.availablePlanes:
data = self._db.getAircraftData(planeID).airplane
if data.planeType in self._availablePlaneTypes:
isPremium = self._db.isPlanePremium(planeID)
isElite = planeID in self._playerAvatar.elitePlanes
isPrimary = planeID in self._playerAvatar.primaryPlanes
planeStatus = PLANE_CLASS.PREMIUM if isPremium else isElite * PLANE_CLASS.ELITE or PLANE_CLASS.REGULAR
self._model.planes.append(
planeID=planeID,
planeNameShort=localizeAirplane(data.name),
planeLevel=data.level,
iconPath=data.iconPath,
planeType=data.planeType,
nation=self._db.getNationIDbyName(data.country),
planeStatus=planeStatus,
isPrimary=isPrimary,
typeIconPath=PLANE_TYPE_ICO_PATH.iconHud(
data.planeType, planeStatus))
self._model.availablePlaneTypes = self._getConvertPlanes()
def onSellPlaneResponse(self, resultID, aircraftID):
"""see AccountCommands.py for actual resultID format"""
LOG_DEBUG('shop.sellPlaneResponse', resultID)
if resultID == OPERATION_RETURN_CODE.SUCCESS:
self.__lobbyCarouselHelper.removeCarouselAirplane(aircraftID)
self.__lobbyCarouselHelper.inventory.syncAircraftsData(
[aircraftID],
partial(self.__sellPlaneResponse, resultID, aircraftID))
else:
if SyncOperationKeeper.getFlagStatus(FLAGS_CODE.SELL_PLANE):
self.__lobby.call_1('shop.sellPlaneResponse', resultID)
SyncOperationKeeper.stop(FLAGS_CODE.SELL_PLANE)
if resultID == OPERATION_RETURN_CODE.FAILURE_MAX_SOLD_PLANES_PER_DAY_REACHED:
msgHeader = localizeMessages('SYSTEM_MESSAGE_ERROR_HEADER')
planeName = localizeAirplane(
db.DBLogic.g_instance.getAircraftName(aircraftID))
msgData = localizeLobby('LOBBY_ERROR_SELL_LIMIT',
plane=planeName)
self.__lobby.showMessageBox(
msgHeader, msgData,
localizeOptions('SAVE_SETTINGS_BUTTON'), None, None, None,
False)
return
def _addAvatarFromInfo(self, avatarInfo, id):
settings = avatarInfo.get('settings')
if not settings:
globalID = avatarInfo['airplaneInfo']['globalID']
import _airplanesConfigurations_db
planeID = _airplanesConfigurations_db.getAirplaneConfiguration(
globalID).planeID
settings = self._db.getAircraftData(planeID)
untypedName = avatarInfo.get('playerName', '')
globalID = avatarInfo['airplaneInfo']['globalID']
currentPlaneType = settings.airplane.planeType
currentRankID = avatarInfo['planeTypeRank'][currentPlaneType]
if type(untypedName) is unicode:
playerName = untypedName
else:
playerName = unicode(untypedName, 'utf-8')
return self._model.avatars.append(
id=id,
clanName=unicode(avatarInfo.get('clanAbbrev', '')),
playerName=playerName,
planeGlobalID=globalID,
isDefender=bool(avatarInfo.get('defendSector')),
isBot=bool(avatarInfo.get('databaseID') == 0),
planeType=settings.airplane.planeType,
planeName=localizeAirplane(settings.airplane.name),
planeLevel=settings.airplane.level,
previewIconPath=settings.airplane.previewIconPath,
teamIndex=getClientTeamIndex(avatarInfo['teamIndex'],
self._playerAvatar.teamIndex),
squadIndex=avatarInfo['squadID'],
maxHealth=int(ceil(avatarInfo['maxHealth'])),
points=avatarInfo['economics']['totalBattlePoints'],
inWorld=False,
state=getLogicState(avatarInfo),
isLost=checkLost(avatarInfo),
rankID=currentRankID)
def _updateBestRankData(self):
avatarInfo = self._clientArena.avatarInfos[self._player.id]
bestPlaneID = avatarInfo['bestRankPlaneID']
planeData = self._db.getAircraftData(bestPlaneID)
planeType = planeData.airplane.planeType
bestRankID = avatarInfo['planeTypeRank'][planeType]
logger.debug('Best rank id = {0}, planeID = {1}'.format(
bestRankID, bestPlaneID))
self._model.bestPlane = localizeAirplane(planeData.airplane.name)
self._model.bestClass = localizeLobby(
PREBATTLE_PLANE_TYPE_NAME[planeType])
self._model.bestPlaneType = planeType
self._model.bestRank = bestRankID
self._model.bestTasks.clean()
for objective in self._player.coachManager.getPlaneTypeObjectives(
planeType):
self._model.bestTasks.append(
id=objective.id,
title=objective.model.client.name.locale,
description=objective.model.client.description.locale,
progress=objective.progressCurrent,
maxProgress=objective.progressMax,
value=objective.progressRawValue,
requiredValue=objective.getNextProgressBound())
def __call__(self, account, ob, **kw):
from Helpers.i18n import localizeAirplane
ob = super(IPlaneNameAdapter, self).__call__(account, ob, **kw)
if 'name' in ob and ob['name']:
ob['name'] = localizeAirplane(ob['name'])
return ob
def __checkEliteStatus(self, planeID, showMsg = True):
"""
check and message elite status for planeID
"""
airplaneData = db.DBLogic.g_instance.getAircraftData(planeID)
if self.__lobbyCarouselHelper.inventory.isAircraftElite(planeID):
self.__lobbyCarouselHelper.refreshAircraftData(planeID, True)
if showMsg:
self.__lobby.call_1('hangar.eliteAircraft', planeID, PLANE_TYPE_ICO_PATH.icon(airplaneData.airplane.planeType, PLANE_CLASS.ELITE), localizeAirplane(airplaneData.airplane.name))
def __call__(self, account, ob, **kw):
if ob is None:
return
else:
cmpUpgrade = None
cmpUpgradeID = None
weaponConfig = None
slotID = None
upgrade = None
upgradeID = None
plane = None
_, typeList = splitIDTypeList(kw['idTypeList'])
if isinstance(ob, list):
for idx in xrange(0, len(typeList)):
if typeList[idx] == 'plane':
plane = ob[idx]
elif typeList[idx] == 'upgrade':
if upgradeID is None:
upgrade = ob[idx]
upgradeID = kw['idTypeList'][idx][0]
else:
cmpUpgrade = ob[idx]
cmpUpgradeID = kw['idTypeList'][idx][0]
elif typeList[idx] == 'weaponConfig':
weaponConfig = ob[idx]
elif typeList[idx] == 'weaponslot':
slotID = ob[idx].id
else:
upgrade = ob
adaptedOb = super(IModuleDescriptionAdapter,
self).__call__(account, ob, **kw)
if upgrade is not None:
outName, specs, planesSet, shortDescription = getUpgradeSpecs(
upgrade, plane.id if plane is not None else None,
cmpUpgrade, slotID, weaponConfig)
elif weaponConfig is None or slotID is None or cmpUpgradeID is None or cmpUpgrade.type not in UPGRADE_TYPE.WEAPON:
return adaptedOb
adaptedOb['configComparison'] = []
adaptedOb['requiredModules'] = []
dbInstance = db.DBLogic.g_instance
cmpGlobalID = 0
if cmpUpgradeID is not None:
import BWPersonality
lch = BWPersonality.g_lobbyCarouselHelper
lobbyAirplane = lch.getCarouselAirplane(
plane.id) or getLobbyAirplane(plane.id)
upgradeName = upgrade.name if upgrade is not None else None
cmpName = cmpUpgrade.name if cmpUpgrade is not None else None
if lobbyAirplane is not None:
upgrades = [
x['name']
for x in lobbyAirplane.modules.getInstalled()
]
weaponList = lobbyAirplane.weapons.getInstalledWeaponsList(
)
if not upgrades:
planeConfig = airplanesConfigurations[
airplanesDefaultConfigurations[plane.id]]
upgrades = planeConfig.modules
weaponList = planeConfig.weaponSlots
cmpGlobalID, newUpgrades, newWeaponList = adjustPlaneConfig(
lobbyAirplane.planeID, upgrades, weaponList,
upgradeName, cmpName, slotID, weaponConfig)
oldGlobalID = db.DBLogic.createGlobalID(
lobbyAirplane.planeID, upgrades, weaponList)
requiredModules = getDiffModules(oldGlobalID, cmpGlobalID,
upgradeName,
(slotID, weaponConfig))
for upgradeName in requiredModules:
reqUpgrade = dbInstance.getUpgradeByName(upgradeName)
name, _, _, _ = getUpgradeSpecs(
reqUpgrade,
plane.id if plane is not None else None, None,
slotID, weaponConfig)
adaptedOb['requiredModules'].append(name)
cmpLobbyAirplane = lobbyAirplane.previewPreset(
newUpgrades, [{
'slot': x[0],
'configuration': x[1]
} for x in newWeaponList])
comparisonSpecs = cmpLobbyAirplane.getGroupedDescriptionFields(
True, lobbyAirplane, cmpGlobalID, False)
for el in comparisonSpecs:
for i, j in el.__dict__.iteritems():
if i != 'main':
continue
specObj = None
if j is not None:
specObj = j.__dict__
if specObj and specObj['comparisonValue']:
adaptedOb['configComparison'].append(specObj)
if not adaptedOb['configComparison']:
adaptedOb['configComparison'] = None
if upgrade is not None:
gunData = dbInstance.getGunData(upgrade.name)
if gunData is None:
moduleType = localizeComponents(
MODULE_GROUP_NAME.get(
getattr(upgrade, 'moduleGroup', None),
MODULE_GROUP_NAME[upgrade.type]))
else:
profileName = gunData.gunProfileName.upper()
if profileName == 'MACHINEGUN_SMALL':
profileName = 'MACHINE_GUN_LOW'
else:
profileName = profileName.replace(
'MACHINEGUN_SMALL', 'MACHINE_GUN')
profileName = profileName.replace('CANNON_HIGH_VULCAN',
'CANNON_HIGH')
moduleType = localizeLobby(
'{0}_DESCRIPTION'.format(profileName))
adaptedOb['name'] = '{0} {1}'.format(moduleType, outName)
adaptedOb['type'] = upgrade.type
adaptedOb['description'] = shortDescription
if hasattr(upgrade, 'level'):
adaptedOb['level'] = upgrade.level
else:
adaptedOb['level'] = 0
adaptedOb['specsList'] = [spec.__dict__ for spec in specs]
adaptedOb['airplanesList'] = map(
lambda x: localizeAirplane(dbInstance.getAircraftName(x)),
filter(lambda x: x in planesSet,
dbInstance.getShopPlaneList()))
adaptedOb['suitablePlaneIDs'] = list(planesSet)
adaptedOb['icoPath'] = get48ModuleIconPath(
getattr(upgrade, 'iconPath', ICON_MODULE_DEFAULT_PATH))
isArmoredTargetEffective = EFFECTIVE_AGAINST_ARMORED_OBJECTS.NORMAL
if upgrade.type in [UPGRADE_TYPE.BOMB, UPGRADE_TYPE.ROCKET]:
isArmoredTargetEffective = EFFECTIVE_AGAINST_ARMORED_OBJECTS.IS_EFFECTIVE
if upgrade.type == UPGRADE_TYPE.GUN:
isArmoredTargetEffective = EFFECTIVE_AGAINST_ARMORED_OBJECTS.NOT_EFFECTIVE if gunData.caliber < MIN_CALIBER else EFFECTIVE_AGAINST_ARMORED_OBJECTS.LOW_EFFECTIVE
adaptedOb['armoredTargetEffective'] = isArmoredTargetEffective
adaptedOb['buyAvailable'] = getattr(upgrade, 'buyAvailable',
True)
if upgrade.type == UPGRADE_TYPE.GUN:
compData = gunData
elif upgrade.type in UPGRADE_TYPE.SHELL:
compData = dbInstance.getComponentByName(
UPGRADE_TYPE_TO_COMPONENT_TYPE[upgrade.type],
upgrade.name)
elif upgrade.type == UPGRADE_TYPE.TURRET:
turret = dbInstance.getTurretData(upgrade.name)
compData = dbInstance.getGunData(turret.hangarSimilarGun)
else:
compData = None
if compData is not None and hasattr(compData, 'tag'):
adaptedOb['propsList'] = [[localizeLobby(x.name), x.type]
for x in compData.tag]
else:
adaptedOb['propsList'] = []
adaptedOb['cmpGlobalID'] = cmpGlobalID
else:
adaptedOb['name'] = ''
adaptedOb['type'] = -1
adaptedOb['description'] = ''
adaptedOb['level'] = 0
adaptedOb['specsList'] = []
adaptedOb['airplanesList'] = []
adaptedOb['suitablePlaneIDs'] = []
adaptedOb['icoPath'] = ''
adaptedOb['armoredTargetEffective'] = False
adaptedOb['buyAvailable'] = False
adaptedOb['cmpGlobalID'] = 0
return adaptedOb