def checkLobbyCrewAnimation(self):
from Helpers.cache import getFromCache
from BWPersonality import g_lobbyCrewBodyType, g_lobbyCrewLastNationID
from _specializations_data import SpecializationEnum
from _skills_data import SkillDB
selectedPlane = self.getCarouselAirplaneSelected()
if not selectedPlane:
return
idTypeList = [[selectedPlane.planeID, 'plane']]
ob = getFromCache(idTypeList, 'IPlaneCrew')
nationID = db.DBLogic.g_instance.getPlaneNationID(selectedPlane.planeID)
if ob:
bodyParam = dict(nation_id=nationID, body_type=CREW_BODY_TYPE.MALE, icon_id=1)
pilotCrew = [-1, 0]
for planeCrew in ob['crewMembers']:
memberID, specSkill = planeCrew['id'], planeCrew['specialization']
if specSkill != SkillDB[specSkill].mainForSpecialization != SpecializationEnum.PILOT:
continue
idTypeList = [[memberID, 'crewmember']]
member = getFromCache(idTypeList, 'ICrewMember')
if member:
nationID = db.DBLogic.g_instance.getPlaneNationID(member['planeSpecializedOn'])
bodyType = member['bodyType']
icoIndex = member['icoIndex']
pilotCrew = [bodyType, icoIndex]
bodyParam = dict(nation_id=nationID, body_type=bodyType, icon_id=icoIndex)
if g_lobbyCrewBodyType[0][SpecializationEnum.PILOT] != pilotCrew or g_lobbyCrewLastNationID != nationID:
g_lobbyCrewBodyType[0][SpecializationEnum.PILOT] = pilotCrew
import BWPersonality
BWPersonality.g_lobbyCrewLastNationID = nationID
LOG_DEBUG('EVENT: HANGAR_PILOT_BODY', bodyParam)
BigWorld.player().callVSE('HANGAR_PILOT_BODY', bodyParam)
def edit(self, account, requestID, idTypeList, data, ob=None, **kw):
adapteddata = getFromCache(idTypeList,
self._iface.ifacename) or dict(ids=[])
if isinstance(data, long):
adapteddata['ids'].append(str(data))
setToCache(idTypeList, self._iface.ifacename, adapteddata)
return adapteddata
def __call__(self, account, ob, **kw):
aob = super(ICrewRanksAdapter, self).__call__(account, ob, **kw)
member = getFromCache([kw['idTypeList'][0]], 'ICrewMember')
country = getObject([[member['planeSpecializedOn'], 'plane']]).country
specialization = SkillDB[member['specialization']].mainForSpecialization
aob['ranks'] = {sp:getRankInfo(sp, specialization, country) for sp in range(1, MAX_SKILL_SP + 1)}
return aob
def responseEventGenerate(headers, respdata):
from exchangeapi.EventUtils import generateEvent
eventName = INDEXTOMETHOD[headers[1]]
for data, idTypeList in respdata:
for ifaceName, ob in data.iteritems():
prevob = getFromCache(idTypeList, ifaceName)
generateEvent(INDEXTOMETHOD[headers[1]], eventName, ifaceName,
idTypeList, None, ob, prevob)
return
def edit(self, account, requestID, idTypeList, data, ob=None, **kw):
cachedata = getFromCache(idTypeList, self._ifacename)
if cachedata:
ids = dict(((int(k), int(v)) for k, v in data['ids'].iteritems()))
for k, v in cachedata['ids'].iteritems():
newval = ids.setdefault(k, v)
if newval != v:
ids[k] = newval
return dict(ids=ids)
return data
def __call__(self, account, ob, **kw):
member = getFromCache([kw['idTypeList'][0]], 'ICrewMember')
newPlaneID = kw['idTypeList'][1][0]
percentList = []
isPremium = db.DBLogic.g_instance.isPlanePremium(newPlaneID)
if not isPremium:
curPlaneSettings = db.DBLogic.g_instance.getAircraftData(member['planeSpecializedOn'])
newPlaneSettings = db.DBLogic.g_instance.getAircraftData(newPlaneID)
if curPlaneSettings.airplane.planeType != newPlaneSettings.airplane.planeType:
percentList.append(50)
else:
percentList.append(70)
return {'percents': percentList if member['planeSpecializedOn'] != newPlaneID else []}
def add(self, account, requestID, data, **kw):
from Helpers.cache import getFromCache
spaceID = data.get('spaceID', '')
if spaceID:
from adapters.IHangarSpacesAdapter import validateSpaceID
from exchangeapi.AdapterUtils import getAdapter
if validateSpaceID(spaceID):
currentHangarSpaceData = getFromCache(
kw['idTypeList'], self._ifacename) or getAdapter(
self._ifacename, ['account']).view(
None, None, EMPTY_IDTYPELIST)
if currentHangarSpaceData is None or currentHangarSpaceData.get(
'spaceID', '') != spaceID:
from gui.Scaleform.utils.HangarSpace import g_hangarSpace
from BWPersonality import g_lobbyCarouselHelper
from db.DBLogic import g_instance as dbInstance
hangarSpace = dbInstance.userHangarSpaces[spaceID]
g_hangarSpace.refreshSpace(hangarSpace['hangarType'],
spaceID)
g_lobbyCarouselHelper.queryRefresh3DModel(
g_lobbyCarouselHelper.getCarouselAirplaneSelected())
return data
return getFromCache(kw['idTypeList'], self._ifacename)
def delete(self, account, requestID, idTypeList, **kw):
from exchangeapi.EventUtils import generateEvent
ob = getFromCache(idTypeList, self._iface.ifacename)
if ob:
LOG_TRACE('Executing callback for package id: {0}'.format(
idTypeList[0][0]))
import BigWorld
from Account import PlayerAccount
player = BigWorld.player()
if player and player.__class__ == PlayerAccount:
popMappedCallback(idTypeList[0][0],
player.processIfaceData)(None, None,
ob['data'])
deleteFromCache(idTypeList, self._iface.ifacename)
generateEvent('delete', 'delete', self._iface.ifacename,
idTypeList, account, {}, ob)
return {}
def __getEquipmentSkillModificator(crewList):
retValue = 1.0
if crewList is None:
return retValue
else:
for _, memberID in crewList:
member = getFromCache([[memberID, 'crewmember']], 'ICrewMember')
if member is None:
continue
skillValue = member['skillValue']
specValue = calculateCommonAndImprovedSkillValue(skillValue)
for skillID in member['skills']:
for mod in SkillDB[skillID].mods:
if hasattr(mod, 'relation') and any((modType == SkillModsTypeEnum.MAIN_HP for modType in mod.relation.type)):
modificator = mod.states.good if hasattr(mod.states, 'good') else mod.states[0]
retValue *= 1 + (modificator - 1) * specValue / 100.0
return retValue
def cacheHandler(request, reqFromCache):
newrequest = []
for data, idTypeList in request:
requestifaces = {}
idList, typeList = splitIDTypeList(idTypeList)
ids = idFromList(idList)
types = idFromList(typeList)
for ifacename in data:
ifacedata = getFromCache(idTypeList, ifacename)
if ifacedata is None:
requestifaces[ifacename] = data[ifacename]
else:
reqFromCache.append([{
ifacename: data[ifacename]
}, idTypeList])
if requestifaces:
newrequest.append([requestifaces, idTypeList])
return newrequest
def __call__(self, account, ob, **kw):
member = getFromCache([kw['idTypeList'][0]], 'ICrewMember')
if member is None:
LOG_ERROR('Try call ISkillPenalty for non-cached crew', [kw['idTypeList'][0]])
return {'penaltyPrc': 100,
'descriptions': [],
'skills': [],
'mainSpecLevel': 50,
'mainSkillLock': False,
'SPLock': False}
else:
planeTo = kw['idTypeList'][1][0]
mainExp = member['mainExp']
skills = member['skills']
expLeftToMain = member['expLeftToMain']
SP = member['SP']
experience = member['experience']
skillValue = member['skillValue']
planeSpecializedOn = member['planeSpecializedOn']
specialization = member['specialization']
return getSkillPenaltyData(planeTo, mainExp, skills, expLeftToMain, SP, experience, skillValue, planeSpecializedOn, specialization)
def cachedata(ifacesFromCache):
for obid in transformedResponse:
for obtype in transformedResponse[obid]:
idTypeList = joinIDTypeList(listFromId(obid),
listFromId(obtype))
idList, typeList = splitIDTypeList(idTypeList)
ids = idFromList(idList)
types = idFromList(typeList)
for parentName, ifaces in transformedResponse[obid][
obtype].iteritems():
for ifacename, attrs in ifaces.iteritems():
if not ifacesFromCache.get(ids, {}).get(
types, {}).get(ifacename, False):
if attrs:
setToCache(idTypeList, ifacename,
attrs)
else:
deleteFromCache(idTypeList, ifacename)
else:
transformedResponse[obid][obtype][
parentName][ifacename] = getFromCache(
idTypeList, ifacename) or {}
def edit(self, account, requestID, idTypeList, data, ob=None, **kw):
from adapters.IHangarSpacesAdapter import validateSpaceID
from Helpers.cache import getFromCache
import BWPersonality
spaceID = data.get('spaceID', '')
if validateSpaceID(spaceID):
import BigWorld
from Account import PlayerAccount
player = BigWorld.player()
if player and player.__class__ == PlayerAccount:
from db.DBLogic import g_instance as dbInstance
switchSpaces = (
hangarSpace for spaceID, hangarSpace in
dbInstance.userHangarSpaces.iteritems()
if hangarSpace.get('switchOnActivation', False))
switchSpace = player.findSuitableHangarSpace(switchSpaces)
BWPersonality.g_settings.hangarSpaceSettings[
'ignoreEventHangar'] = switchSpace is not None and switchSpace[
'spaceID'] != spaceID
BWPersonality.g_settings.hangarSpaceSettings['spaceID'] = spaceID
return data
else:
return getFromCache(idTypeList, self._ifacename)
def sendDataToUICallbacks(headers, respdata, callback, ifacehandler = None, data = UI_CALLBACKS, fromserver = False, broadcast = True, proccesedIfaces = None):
data = dict(data)
from Helpers.ExchangeObBuilder import ExchangeObBuilder, cacheIFaceData, responseEventGenerate
from Helpers.cache import getFromCache
proccesedIfaces = proccesedIfaces or dict()
if callback:
ifacehandler.addResponseCallbackToQueue(partial(ifacehandler.call_1, callback, convertIfaceDataForUI(respdata), 0))
for ifaces, idTypeList in respdata:
ids, types = map(idFromList, splitIDTypeList(idTypeList))
for ifacename in ifaces:
if ifacename in proccesedIfaces.get(ids, {}).get(types, set([])):
continue
ifacedata = {ifacename: ifaces[ifacename]}
idata = [[ifacedata, idTypeList]]
iface = getIface(ifacename)
if fromserver:
from Helpers.ExchangeObBuilder import processIFaceData
processIFaceData([int(not IS_CLIENT), METHODTOINDEX['view']], idata)
responseEventGenerate(headers, idata)
cacheIFaceData(idata)
if ifacedata[ifacename]:
for c in getDefaultCallbacks(ifacename, ifacehandler, data):
addUICallback([[{ifacename: True}, idTypeList]], c, ifacehandler, data)
data.update(UI_CALLBACKS)
if iface.parent:
def constructed(ifacehandler, fromserver, broadcast, proccesedIfaces, responseob):
if responseob[-1] == ErrorCodes.SUCCESS:
responseEventGenerate([int(not consts.IS_CLIENT), METHODTOINDEX['edit']], responseob[1])
sendDataToUICallbacks(responseob[0], responseob[1], None, ifacehandler, data, fromserver, broadcast, proccesedIfaces)
return
requestob = [[int(consts.IS_CLIENT)], [[{ifacename: {}}, idTypeList]], METHODTOINDEX['view']]
builder = ExchangeObBuilder(requestob, False)
builder.setFinishCallback(partial(constructed, ifacehandler, False, broadcast, proccesedIfaces))
builder.build()
continue
elif ifacedata[ifacename]:
for c in getDefaultCallbacks(ifacename, ifacehandler, data):
addUICallback([[{ifacename: True}, idTypeList]], c, ifacehandler, data)
data.update(UI_CALLBACKS)
proccesedIfaces.setdefault(ids, {}).setdefault(types, set([])).update([ifacename])
callbacks = set(data.get(ids, {}).get(types, {}).get(ifacename, []))
if callbacks:
for parentname in iface.parent:
PARENT_INTERFACES.setdefault(ids, {}).setdefault(types, set([])).update([ifacename])
for item in callbacks:
if item != callback:
if broadcast and ifacehandler:
debug_utils.LOG_DEBUG('UICallbackUtils:Iface:response', idata, item)
convertedIDTypeList = convertIDTypeListForUI(idTypeList)
if not convertedIDTypeList:
obid = None
obtype = None
else:
obid = convertedIDTypeList[0][0]
obtype = convertedIDTypeList[0][1]
ifacehandler.addResponseCallbackToQueue(partial(ifacehandler.call_1, item, [[ifacedata, obid, obtype]] if idTypeList is not None and len(idTypeList) < 2 else [[ifacedata, convertedIDTypeList]], 0))
if not fromserver and ifacedata[ifacename]:
addUICallback(idata, item, ifacehandler, data)
elif not ifacedata[ifacename]:
removeUICallback(idata, item, ifacehandler, data)
if broadcast and ifacehandler:
for parentname in iface.parent:
if parentname in proccesedIfaces.get(ids, {}).get(types, set([])):
continue
piface = getIface(parentname)
cacheddata = getFromCache(idTypeList, parentname) or {}
parentdata = dict(((attr, ifaces[ifacename].get(attr, cacheddata.get(attr, None))) for attr in piface.attr))
if parentdata:
iparentdata = [[{parentname: parentdata}, idTypeList]]
responseEventGenerate([int(consts.IS_CLIENT), METHODTOINDEX['edit']], iparentdata)
sendDataToUICallbacks(headers, iparentdata, None, ifacehandler, data, fromserver, broadcast, proccesedIfaces)
pnames = list(PARENT_INTERFACES.get(ids, {}).get(types, set([])))
for pname in pnames:
if pname in proccesedIfaces.get(ids, {}).get(types, set([])):
continue
def constructed(ifacehandler, broadcast, proccesedIfaces, responseob):
if responseob[-1] == ErrorCodes.SUCCESS:
responseEventGenerate([int(consts.IS_CLIENT), METHODTOINDEX['edit']], responseob[1])
sendDataToUICallbacks(responseob[0], responseob[1], None, ifacehandler, data, False, broadcast, proccesedIfaces)
return
requestob = [[int(consts.IS_CLIENT)], [[{pname: {}}, idTypeList]], METHODTOINDEX['view']]
builder = ExchangeObBuilder(requestob, False)
builder.setFinishCallback(partial(constructed, ifacehandler, broadcast, proccesedIfaces))
builder.build()
return
def onResponseObBuilt(transformedResponse, reqFromCache, headers,
code):
if self.__requestCount:
return
def data():
for obid in transformedResponse:
for obtype in transformedResponse[obid]:
idTypeList = joinIDTypeList(listFromId(obid),
listFromId(obtype))
ifacesdata = {}
for parent, ifaces in transformedResponse[obid][
obtype].iteritems():
ifacedata = {}
for attrs in ifaces.itervalues():
ifacedata.update(attrs)
ifacesdata[parent] = ifacedata
yield [ifacesdata, idTypeList]
def cachedata(ifacesFromCache):
for obid in transformedResponse:
for obtype in transformedResponse[obid]:
idTypeList = joinIDTypeList(listFromId(obid),
listFromId(obtype))
idList, typeList = splitIDTypeList(idTypeList)
ids = idFromList(idList)
types = idFromList(typeList)
for parentName, ifaces in transformedResponse[obid][
obtype].iteritems():
for ifacename, attrs in ifaces.iteritems():
if not ifacesFromCache.get(ids, {}).get(
types, {}).get(ifacename, False):
if attrs:
setToCache(idTypeList, ifacename,
attrs)
else:
deleteFromCache(idTypeList, ifacename)
else:
transformedResponse[obid][obtype][
parentName][ifacename] = getFromCache(
idTypeList, ifacename) or {}
ifacesFromCache = {}
for reqData, idTypeList in reqFromCache:
idList, typeList = splitIDTypeList(idTypeList)
ids = idFromList(idList)
types = idFromList(typeList)
for ifacename in reqData:
reqData[ifacename] = getFromCache(idTypeList,
ifacename) or {}
ifacesFromCache.setdefault(ids, {}).setdefault(
types, {})[iface_name(ifacename)] = True
saveIfaceData(transformedResponse, reqFromCache)
idata = list(data())
if code == ErrorCodes.SUCCESS:
if self.__generateEvent:
responseEventGenerate(headers, idata)
cachedata(ifacesFromCache)
responseob = [
headers, idata if code == ErrorCodes.SUCCESS else
ErrorCodes.ERROR_DESCRIPTION.get(code, 'Unknown error'), code
]
self.__onBuildFinishedCallback(responseob)
def __call__(self, account, ob, **kw):
member = getFromCache([kw['idTypeList'][0]], 'ICrewMember')
dropLevel = [ [0, item.level] for item in _economics.Economics.crewSkillsDropCost.items ]
return {'dropResults': dropLevel if member and len(member['skills']) > 0 else []}
def getCacheData(self, idTypeList, account):
return cache.getFromCache(idTypeList, self._ifacename) or self.__call__(account, {})
def view(self, account, requestID, idTypeList, ob=None, **kw):
return getFromCache(idTypeList, self._iface.ifacename)
def __call__(self, account, ob, **kw):
return super(ILastProcessedResponseAdapter, self).__call__(
account, (getFromCache(EMPTY_IDTYPELIST, self._iface.ifacename)
or self.add(None, None, {'rid': 0})), **kw)
def getBattleResult(obid, account=None):
from Helpers.cache import getFromCache
return getFromCache([[obid, 'battleResult']], 'IBattleResult')
