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)