def __onUpdatePlayerStats(self, argStr):
stats = wgPickle.loads(wgPickle.FromServerToClient, argStr)
avatarInfo = self.avatarInfos.get(stats['avatarID'], None)
if avatarInfo:
avatarInfo['stats'] = stats
self.onUpdatePlayerStats(avatarInfo)
return
def __onReceiveTextMessage(self, argStr):
senderID, messageType, messageStringID, targetID, message = wgPickle.loads(
wgPickle.FromServerToClient, argStr)
avatarsInfo = self.avatarInfos
senderInfo = avatarsInfo.get(senderID, None)
if senderInfo:
if BotChatHelper.isBotChatMessage(messageType):
message = BotChatHelper.convertMessage(
message, self.avatarInfos, senderInfo,
targetID).encode('utf-8')
messageType = BotChatHelper.convertMessageType(messageType)
targetID = 0
if messageType == MESSAGE_TYPE.BATTLE_ALL and senderInfo[
'teamIndex'] != BigWorld.player().teamIndex:
messageType = MESSAGE_TYPE.BATTLE_ALL_FROM_OPPONENT
try:
msg = 'Player %s(%s) say: %s' % (self.getObjectName(
senderID), senderID, unicode(message, encoding='utf-8'))
ClientLog.g_instance.gameplay(msg.encode('utf-8'))
except:
LOG_ERROR('__onReceiveTextMessage', senderID, message)
return
self.onReceiveTextMessage(senderID, messageType, messageStringID,
targetID, message, False)
return
def __onDebugInfoReceived(self, argStr):
from Math import Matrix, Vector3
positions = wgPickle.loads(wgPickle.FromServerToClient, argStr)
for planeID, pos in positions:
m = Matrix()
m.setTranslate(pos)
BigWorld.addPoint('spawnPoint%d' % planeID, m, 4278190335L, False)
def __onEconomicEvents(self, argStr):
events = wgPickle.loads(wgPickle.FromServerToClient, argStr)
isKill = any((len(eventData) == 2 for eventData in events))
if isKill:
BigWorld.callback(0.5, partial(self.onEconomicEvents, events))
else:
self.onEconomicEvents(events)
def receiveOperation(self, invocationId, operationCode, argStr):
"""
Receives operation
@param operationCode: operation code
@param invocationId: invocation id of the received operation, need for response
@param argStr: pickled operation arguments
"""
if self.__operations.has_key(invocationId):
LOG_ERROR('Received duplicate invocation id ({0} {1})'.format(
invocationId, self.__operations[invocationId].__dict__))
self.__operations[invocationId].destroy()
args = None
if argStr:
try:
args = wgPickle.loads(self.__loadsTransferType, argStr)
if not isinstance(args, tuple):
LOG_ERROR(
'Incoming operation args are corrupted (not a tuple)')
return
except Exception:
LOG_ERROR('Unable to load incoming operation argStr')
return
operation = ReceivedOperation(self, operationCode, invocationId, args)
operation.onDestroy += self.__onOperationDestroy
self.__operations[operation.invocationId] = operation
self._onReceiveOperation(operation)
return
def update(self, infoMap):
for k, v in infoMap.items():
if not hasattr(self, k):
LOG_ERROR('Missing attr %s in InitPlayerInfo' % str(k))
if k == 'AOGASParams' and isinstance(v, basestring):
v = wgPickle.loads(wgPickle.FromServerToClient, v)
setattr(self, k, v)
def __updateData(self):
if self.__lazyInitialization:
arbiter = BigWorld.globalData.get('Arbiter', False)
if arbiter:
self.__lazyInitialization = False
for dvKey, keyDescription in self.__dvKeyArray.iteritems():
arbiter.addNewKey(dvKey, wgPickle.dumps(wgPickle.FromServerToServer, keyDescription))
else:
return
else:
_buffer = {}
for dvKey, dataObj in self.__storage.iteritems():
for viewerId, mask in self.__filter.iteritems():
is_new_viewer = viewerId in self.__newViewers
in_mask = dvKey in mask
is_change = self.__storage[dvKey].is_change
if in_mask and (is_change or is_new_viewer):
_buffer.setdefault(viewerId, {})[dvKey] = dataObj.data
self.__storage[dvKey].is_change = False
_puck_buffer = dict(((ID, wgPickle.dumps(wgPickle.FromServerToClient, single_buffer)) for ID, single_buffer in _buffer.iteritems()))
if len(_puck_buffer):
if IS_CLIENT:
fromClient = _puck_buffer.get(-1, None)
if fromClient:
fromClient = wgPickle.loads(wgPickle.FromServerToClient, fromClient)
BigWorld.player().debugViewer_pushToView(wgPickle.dumps(wgPickle.FromServerToServer, fromClient))
else:
BigWorld.globalData['Arbiter'].pushToView(wgPickle.dumps(wgPickle.FromServerToServer, _puck_buffer))
self.__newViewers.clear()
return
def __onUpdateTeamSuperiorityPoints(self, argStr):
score = wgPickle.loads(wgPickle.FromServerToClient, argStr)
ownScore, enemyScore = self.__convertServerTeamDataToOwnClientTeamData(
score)
self.onUpdateTeamSuperiorityPoints(self.superiorityPoints, ownScore,
enemyScore)
self.superiorityPoints[0], self.superiorityPoints[
1] = ownScore, enemyScore
def __onReceiveTeamObjectsUpdate(self, argStr):
self.__updatedObjectsData.clear()
objectsList = wgPickle.loads(wgPickle.FromServerToClient, argStr)
for r in objectsList:
record = getTeamObjectDescriptorFromCompactUpdateDescriptor(r)
objID = record['id']
self.__updatedObjectsData[objID] = record
self.onReceiveTeamObjectsDataUpdate()
def update(self, updateFunctionID, argStr):
handledInArena = self.__callUpdateFunction(updateFunctionID, argStr)
handledInGM = self.gameMode.onArenaUpdate(
updateFunctionID,
wgPickle.loads(wgPickle.FromServerToClient, argStr))
if not (handledInArena or handledInGM):
self.logger.error(
'function not found updateFunctionID = {0}'.format(
updateFunctionID))
def __onReceiveAllTeamObjectsData(self, argStr):
objectsList, serverTeamObjectsCheckSum = wgPickle.loads(
wgPickle.FromServerToClient, argStr)
LOG_INFO('__onReceiveAllTeamObjectsData')
player = BigWorld.player()
arenaType = player.arenaType
arenaSettings = db.DBLogic.g_instance.getArenaData(arenaType)
arenaObjects = arenaSettings.arenaObjects
if arenaObjects.teamObjectsCheckSum != serverTeamObjectsCheckSum:
CRITICAL_ERROR(
'Invalid teamObjectsCheckSum - sync your server with client please!'
)
BigWorld.setArenaDefScripts(arenaSettings.arenaScripts)
for r in objectsList:
record = getTeamObjectDescriptorFromCompactDescriptor(r)
objID = record['id']
arenaObjID = record['arenaObjID']
maxHealth = record['maxHealth']
objArenaData = arenaSettings.getTeamObjectData(arenaObjID)
modelStrID = objArenaData['modelID']
settings = db.DBLogic.g_instance.getEntityDataByName(
db.DBLogic.DBEntities.BASES, modelStrID)
classID = EntitySupportedClasses.TeamTurret if settings.type == TYPE_TEAM_OBJECT.TURRET else EntitySupportedClasses.TeamObject
modelID = settings.typeID
teamIndex = record['teamIndex']
groupName = objArenaData['groupName']
ACType = objArenaData.get('ACType', -1)
isRepair = ACType == GROUND_OBJECT_TYPE.REPAIR
if isRepair:
LOG_DEBUG('repair Zone activate', objID, groupName)
isRecharg = ACType == GROUND_OBJECT_TYPE.RECHARGE
if isRecharg:
LOG_DEBUG('Recharg Zone activate', objID, groupName)
self.createTeamObjectControllers(objID, settings)
self.__allObjectsData[objID].update({
'groupName': groupName,
'classID': classID,
'teamIndex': teamIndex,
'settings': settings,
'modelID': modelID,
'maxHealth': maxHealth,
'valid': True,
'isRepair': isRepair,
'isRecharg': isRecharg,
'ACType': ACType
})
self.__alwaysVisibleObjects.addAllTimeVisibleObject(
objID, classID, teamIndex, record['pos'], record['isAlive'],
modelID)
name = objArenaData['DsName']
if name and name not in self.__scenarioObjectMap:
self.__scenarioObjectMap[name] = (self.__allObjectsData[objID],
objArenaData, objID)
self.onReceiveAllTeamObjectsData()
self.__isTeamObjectsReceived = True
def onCmdResponse(self, requestID, resultID, responseDataStr):
"""
Unpack response and fire callback by requestID
:param requestID: id passed in doCmd method.
:param resultID: command result.
:param responseDataStr: pickled response
"""
callback = self.deferredRequests.pop(requestID, self.__onCmdCallback)
args = wgPickle.loads(wgPickle.FromServerToClient, responseDataStr)
callback(requestID, resultID, args)
def __onTeamObjectDestruction(self, argStr):
killingInfo = wgPickle.loads(wgPickle.FromServerToClient, argStr)
victimData = self.__allObjectsData[killingInfo['victimID']]
superiorityPoints, superiorityPointsMax = self.getSuperiorityPoints4TeamObject(
killingInfo['victimID'])
points = killingInfo.get('points', superiorityPoints)
self.onTeamObjectDestruction(killingInfo['killerID'],
killingInfo['victimID'],
victimData['settings'].type,
victimData['teamIndex'], points,
superiorityPointsMax)
def setFilter(self, viewerId, data):
try:
mask = wgPickle.loads(wgPickle.FromClientToServer, data)
except Exception as e:
LOG_ERROR('DebugManager::setFilter. Cant load: ', data)
return
self.__setSettingToViewData(mask)
self.__filter[viewerId] = mask
if len(mask):
self.__newViewers.add(viewerId)
def unpackAgrumentString(self, argStr):
"""
Unpacks arguments received with the response
@param argStr: packed arguments
@return: unpacked arguments
@throws Exception: if there were any errors during unpack
"""
try:
return wgPickle.loads(self.__loadsTransferType, argStr)
except Exception:
LOG_ERROR('Unable to load incoming operation argStr: {0}'.format(argStr))
raise
def __onPlaneTypeRankUpdated(self, payload):
avatarID, rankData, bestRankPlaneID = wgPickle.loads(
wgPickle.FromServerToClient, payload)
avatarInfo = self.avatarInfos[avatarID]
oldRankData = avatarInfo['planeTypeRank']
avatarInfo['planeTypeRank'] = rankData
avatarInfo['bestRankPlaneID'] = bestRankPlaneID
for planeType, rankID in avatarInfo['planeTypeRank'].iteritems():
oldRankID = oldRankData[planeType]
if oldRankID != rankID:
self.onAvatarPlaneTypeRankChanged(avatarID, planeType,
oldRankID, rankID)
def __onBaseIsUnderAttack(self, argStr):
objID = wgPickle.loads(wgPickle.FromServerToClient, argStr)
objectType = self.getTeamObjectType(objID)
if objectType:
obj = BigWorld.entities.get(objID)
if not obj:
obj = self.getMapEntry(objID)
if obj and getattr(obj, 'isAlive', True):
self.onBaseIsUnderAttack(obj.position, obj.teamIndex,
objectType)
else:
LOG_ERROR('__onBaseIsUnderAttack - objectType undefined (%s)' %
objID)
def __onUpdateObjectsData(self, argStr):
data = wgPickle.loads(wgPickle.FromServerToClient, argStr)
for updatableData in data:
objID, _, __, ___ = updatableData
objData = self.avatarInfos.get(objID, None)
if not objData:
objData = self.__allObjectsData.get(objID, None)
if objData:
if objData.has_key('classID'):
self.__alwaysVisibleObjects.updateTemporaryVisibleObjectData(
updatableData, objData['classID'],
objData['teamIndex'], objData.get('modelID', None))
return
def __onEconomicExtPlayersData(self, argStr):
avatarID, economics = wgPickle.loads(wgPickle.FromServerToClient,
argStr)
avatarInfo = self.avatarInfos[avatarID]
avatarInfo['economics'] = economics
self.onPlayerEconomicExtDataReceived(avatarID)
def __onScenarioSetIcon(self, argStr):
groupName, iconIndex, textID, temaIndex = wgPickle.loads(
wgPickle.FromServerToClient, argStr)
self.onScenarioSetIcon(groupName, iconIndex, textID, temaIndex)
def __onScenarioSetText(self, argStr):
textID, colorID = wgPickle.loads(wgPickle.FromServerToClient, argStr)
self.onScenarioSetText(textID, colorID)
def __onGameResultChanged(self, argStr):
gameResult, winState = wgPickle.loads(wgPickle.FromServerToClient,
argStr)
self.onGameResultChanged(gameResult, winState)
def __onTeamObjectPartGroupDestroyed(self, argStr):
for teamObjectID, points, killerID in wgPickle.loads(
wgPickle.FromServerToClient, argStr):
self.__decSuperiorityPoints4TeamObject(teamObjectID, points)
self.onTeamObjectPartGroupChanged(killerID, teamObjectID, points)
def __onReceiveVOIPChannelCredentials(self, argStr):
name, teamMembers = wgPickle.loads(wgPickle.FromServerToClient, argStr)
self.onReceiveVOIPChannelCredentials(name, teamMembers)
def __onReportBattleResult(self, argStr):
clientBattleResult = translateDictThroughAnother(
wgPickle.loads(wgPickle.FromServerToClient, argStr),
REPORT_BATTLE_RESULT_KEYS_INVERT_DICT)
self.onReportBattleResult(clientBattleResult)
def __onUpdateDominationPrc(self, argStr):
basesPrc = wgPickle.loads(wgPickle.FromServerToClient, argStr)
self.dominationPrc[0], self.dominationPrc[
1] = self.__convertServerTeamDataToOwnClientTeamData(basesPrc)
self.onUpdateDominationPrc(self.dominationPrc)
def __onReceiveTurretBoosterInfo(self, argStr):
teamIndex = wgPickle.loads(wgPickle.FromServerToClient, argStr)
self.onUpdateTurretBoosterInfo(
teamIndex == BigWorld.player().teamIndex)
CACHE_TABLE_NAME = 'cache'
CHECK_TABLE_EXIST = 'SELECT count(*) FROM sqlite_master WHERE type="table" AND name="%s"' % CACHE_TABLE_NAME
CREATE_TABLE = 'CREATE table %s (id INT64 PRIMARY KEY, data BLOB, expiringTime FLOAT)' % CACHE_TABLE_NAME
GET_DATA = 'SELECT data, expiringTime FROM %s WHERE id = ?' % CACHE_TABLE_NAME
SET_DATA = 'INSERT OR REPLACE INTO %s VALUES (?, ?, ?)' % CACHE_TABLE_NAME
DELETE_DATA = 'DELETE FROM %s WHERE id = ?' % CACHE_TABLE_NAME
REINDEX = 'REINDEX'
VACUUM = 'VACUUM'
CLEAR_CACHE_TAG = 'clear-cache'
CLEAR_CACHE_DONE = False
SQL_CONNECTION = None
CACHE_PATH = None
ID_TYPE = int
encoder = lambda data: base64.b64encode(
wgPickle.dumps(wgPickle.FromClientToClient, data, compress=False))
decoder = lambda data: wgPickle.loads(wgPickle.FromClientToClient,
base64.b64decode(data))
def init(cachePath):
global CACHE_PATH
global CLEAR_CACHE_DONE
CACHE_PATH = cachePath
LOG_DEBUG('Init sql cache...')
if CLEAR_CACHE_TAG in sys.argv and not CLEAR_CACHE_DONE:
LOG_DEBUG('Delete sql cache from command line option...')
deleteCache()
CLEAR_CACHE_DONE = True
LOG_DEBUG('Done')
__createCacheStorage()
def setPrebattleStatistic(self, queueStatisticPacked):
self.__queueStatistic = wgPickle.loads(wgPickle.FromServerToClient,
queueStatisticPacked)
def __onReceiveLaunch(self, argStr):
avatarID, shellsCount = wgPickle.loads(wgPickle.FromServerToClient,
argStr)
self.avatarInfos[avatarID]['shellsCount'] = shellsCount
self.onLaunch(avatarID)
