class RainbowFishGroup(object): """ 彩虹鱼鱼群 """ def __init__(self, table): self.table = table self._interval = 100 # 间隔 self._totalTime = 0 # 总时间 self._nextRainbowTimer = None # 下一波彩虹鱼 self._setRainbowTimer() def clearTimer(self): if self._nextRainbowTimer: self._nextRainbowTimer.cancel() self._nextRainbowTimer = None def _setRainbowTimer(self): """启动彩虹鱼定时器""" self.clearTimer() self._nextRainbowTimer = FTLoopTimer(self._interval, -1, self._addRainbowFishGroup) self._nextRainbowTimer.start() def _addRainbowFishGroup(self): """添加彩虹鱼""" self._totalTime += self._interval if self._totalTime % 3 == 0: return rainbowGroupId = random.choice(self.table.runConfig.allRainbowGroupIds) if rainbowGroupId: if ftlog.is_debug(): ftlog.debug("_addRainbowFishGroup", self.table.tableId, rainbowGroupId) self.table.insertFishGroup(rainbowGroupId)
def _addUserCouponFishGroupNew(self, groupId, userId, totalBullet): """ 添加个人可见的奖券鱼 """ player = self.table.getPlayer(userId) self._clearPlayerTimer(userId) if player: playerBullet = player.couponConsumeClip if playerBullet < totalBullet: timer = FTLoopTimer(10, 0, self._addUserCouponFishGroupNew, groupId, userId, totalBullet) timer.start() self._playerCouponTimerDict[userId] = timer if ftlog.is_debug(): ftlog.debug( "_addUserCouponFishGroupNew, check later, tableId =", self.table.tableId, "userId =", userId, "playerBullet =", playerBullet, "totalBullet =", totalBullet) else: player.resetCouponConsumeClip() if ftlog.is_debug(): ftlog.debug("_addUserCouponFishGroupNew, tabId =", self.table.tableId, "userId =", userId, "groupId =", groupId) self.table.insertFishGroup(groupId, userId=userId, sendUserId=userId) self._checkUserConditionNew(userId)
def _addCouponFishGroup(self, userId): """ 添加红包券鱼 """ if ftlog.is_debug(): ftlog.debug("_addCouponFishGroup", userId, self.table.tableId) player = self.table.getPlayer(userId) catchCouponFishCount = gamedata.getGameAttrInt( userId, FISH_GAMEID, GameData.catchCouponFishCount) if player and player.taskSystemUser and player.taskSystemUser.curTask: if catchCouponFishCount < 10 or player.taskSystemUser.curTask.taskConfig[ "type"] == TaskType.CatchRedPacketFishNum: taskId = player.taskSystemUser.getCurMainTaskId() newbieFishGroupConf = config.getPublic("newbieFishGroupConf", {}) couponFishGroups = newbieFishGroupConf.get( str(taskId), {}).get("couponFishGroups", []) data = self._playerCouponTimerDict.get(userId) if couponFishGroups and (not data or data[1].getTimeOut() <= 0): group = self.table.insertFishGroup( random.choice(couponFishGroups), userId=userId, sendUserId=userId) timer = FTLoopTimer(group.totalTime, 0, self._addCouponFishGroup, userId) timer.start() self._playerCouponTimerDict[userId] = [group, timer]
class FishPlayerBuffer(object): """回馈赛的buffer""" def __init__(self, player, bufferId): self.player = player self.bufferId = bufferId self._state = BUFFER_STATE.NOEFFECT self.startTime = 0 self.bufferConf = config.getPlayerBufferConf(bufferId) self.checkTimer = FTLoopTimer(self.bufferConf["delayTime"], -1, self._bufferStart) self.checkTimer.start() self.sendMsgTimer = None def getBufferId(self): return self.bufferId def isStart(self): return self._state == BUFFER_STATE.START def _bufferStart(self): if self.checkTimer: self.checkTimer.cancel() self._state = BUFFER_STATE.START self.startTime = int(time.time()) pass
def regPPSCounter(funCount): global _ppsTimer if callable(funCount): if _ppsTimer == None: _ppsTimer = FTLoopTimer(3, -1, _ppsCounter) _ppsTimer.start() if funCount not in _ppsFunCounts: _ppsFunCounts.append(funCount)
def _newJoinTaskAfterTheStart(self, userId): """ 任务开始后加入任务 """ fun = self._funMap.get(self.currTask, None) if fun: timer = FTLoopTimer(1, 0, fun.newJoinTaskForAfterTheStart, userId) timer.start()
def __init__(self, markParams, argl, argd): super(_FutureResultLocal, self).__init__() try: ftt = FTLoopTimer(0.01, 0, self._invokeLocal, markParams, argl, argd) ftt.start() except Exception, e: self._status = FutureResult.STATUS_ERROR self._exception = e ftlog.error()
def _generalCategoryTimer(self): """ 生成并存储各类鱼的定时器 """ self.clearCategoryTimer() for categoryId, categoryConf in self.autofillFishConf.iteritems(): interval = categoryConf["cSupplyInterval"] checkTimer = FTLoopTimer(interval, -1, self._checkCategoryAutoFillFish, categoryId) checkTimer.start() self._checkCategoryTimerList.append(checkTimer)
def _initialize(): ftlog.debug('endgame._initialize begin') global _inited if not _inited: _inited = True _reloadConf() pkeventbus.globalEventBus.subscribe(EventConfigure, _onConfChanged) loop_timer = FTLoopTimer(3600, -1, process_players) loop_timer.start() ftlog.debug('endgame._initialize end')
class PlatterFishGroup(object): """ 大盘鱼群 """ def __init__(self, table): self.table = table self._fishType = 0 self._interval = 10 self._platterGroupId = None self._nextPlatterTimer = None self._setPlatterTimer() def clearTimer(self): """清理定时器""" if self._nextPlatterTimer: self._nextPlatterTimer.cancel() self._nextPlatterTimer = None def _setPlatterTimer(self): """启动大盘鱼群定时器""" self.clearTimer() self._fishType, self._interval = self._randomFishTypeAndInterval() self._nextPlatterTimer = FTLoopTimer(self._interval, -1, self._addPlatterFishGroup) self._nextPlatterTimer.start() def _addPlatterFishGroup(self): """添加大盘鱼群""" if self._fishType not in self.table.runConfig.allPlatterGroupIds: return if self.table.hasTideFishGroup(): # 当前渔场存在鱼潮 return platterGroupIds = self.table.runConfig.allPlatterGroupIds[ self._fishType] if platterGroupIds: self._platterGroupId = random.choice(platterGroupIds) self.table.insertFishGroup(self._platterGroupId) self._fishType, _ = self._randomFishTypeAndInterval() def _randomFishTypeAndInterval(self): """随机鱼Id和间隔""" fishType = 0 interval = 10 randomNum = random.randint(1, 10000) for platterFishMap in config.getPlatterFishConf( self.table.runConfig.fishPool): probb = platterFishMap["probb"] if probb[0] <= randomNum <= probb[-1]: fishType = int(platterFishMap["fishType"]) interval = int(platterFishMap["interval"]) break if interval != self._interval and self._nextPlatterTimer is not None: self._interval = interval self._setPlatterTimer() return fishType, interval
def startAutofill(self, uid, taskId): """ 开始填充 """ if uid is None: uid = 0 else: uid = int(uid) if taskId == 0 or taskId == self.taskId.get(uid): return if self.overTimeTimer.get(uid): self.overTimeTimer[uid].cancel() self.overTimeTimer.pop(uid) if self.autofillTimerList.get(uid): for _timer in self.autofillTimerList[uid]: if _timer: _timer.cancel() self.autofillTimerList.pop(uid) taskConf = None # 任务配置 for val in self.tasks[:]: if int(val["taskId"]) == int(taskId): taskConf = val break if taskConf is None: ftlog.warn("TTAutofillFishGroup, uid =", uid, "taskId =", taskId, "not find !") return if taskConf.get("taskType", 0) != 1: ftlog.warn("TTAutofillFishGroup, uid =", uid, "taskId =", taskId, "type not match !") return self.taskId[uid] = taskId targets = taskConf.get("targets", {}) target1 = targets.get("target1", 0) inter1 = targets.get("inter1", 0) target2 = targets.get("target2", 0) inter2 = targets.get("inter2", 0) if target1 and inter1: FTLoopTimer(0.1, 0, self._addAutofillFishGroup, target1).start() _timer = FTLoopTimer(inter1, -1, self._addAutofillFishGroup, target1) _timer.start() self.autofillTimerList.setdefault(uid, []).append(_timer) if target2 and inter2: FTLoopTimer(0.1, 0, self._addAutofillFishGroup, target2).start() _timer = FTLoopTimer(inter2, -1, self._addAutofillFishGroup, target2) _timer.start() self.autofillTimerList.setdefault(uid, []).append(_timer) self.overTimeTimer[uid] = FTLoopTimer( taskConf.get("timeLong", 60) + 5, 0, self._overTime, uid) self.overTimeTimer[uid].start() if ftlog.is_debug(): ftlog.debug("TTAutofillFishGroup, start, uid =", uid, "taskId =", self.taskId)
def _generalShoalTimer(self): """ 生成并存储各类鱼的鱼群定时器 """ self.clearShoalTimer() for categoryId, categoryConf in self.autofillFishConf.iteritems(): interval = categoryConf["sSupplyInterval"] if interval > 0: checkTimer = FTLoopTimer(interval, -1, self._checkAutoFillFishShoal, categoryId) checkTimer.start() self._checkShoalTimerList.append(checkTimer)
class DizhuManagerPlayerTableRoom(DizhuTableRoom): def __init__(self, roomDefine, clearIdleInterval=10): super(DizhuManagerPlayerTableRoom, self).__init__(roomDefine) # 玩家map self._playerMap = {} # 空闲的玩家Map self._idlePlayerMap = LastUpdatedOrderedDict() # 定时器清理超时的player self._clearIdlePlayerTimer = FTLoopTimer(clearIdleInterval, -1, self._clearIdlePlayes) self._clearIdlePlayerTimer.start() self._keyLock = KeyLock() @property def keyLock(self): return self._keyLock def _addPlayer(self, player): self._playerMap[player.userId] = player self._addIdlePlayer(player) self.fire(UserEnterRoomEvent(self, player)) def _addIdlePlayer(self, player): player.idleTime = pktimestamp.getCurrentTimestamp() self._idlePlayerMap[player.userId] = player def _removeIdlePlayer(self, player): try: del self._idlePlayerMap[player.userId] except: pass def _leaveRoom(self, player, reason): assert (not player.seat) if player.isAI: return self._removeIdlePlayer(player) try: del self._playerMap[player.userId] self.fire(UserLeaveRoomEvent(self, player, reason)) # ftlog.info('DizhuManagerPlayerTableRoom._leaveRoom', # 'roomId=', self.roomId, # 'userId=', player.userId, # 'reason=', reason) clientId = player.clientId bireport.reportGameEvent('LEAVE_ROOM', player.userId, self.gameId, self.roomId, 0, 0, 0, reason, 0, [], clientId, 0, 0) except Exception, e: ftlog.error('room_leave BI error', 'gameId=', self.gameId, 'roomId=', self.roomId, 'userId=', player.userId, 'err=', e.message)
def _sendTaskInfoForReconnect(self, userId): """ 用户断线重连发送任务相关信息 """ if util.isRedRoom(self.table.typeName): return self._sendTaskInfo() player = self.table.getPlayer(userId) if player and player.currentTask: task = player.currentTask[0] fun = self._funMap.get(task, None) if fun: timer = FTLoopTimer(1, 0, fun.sendTaskInfoForReconnect, userId) timer.start()
class MultipleFishGroup(object): """ 倍率鱼群(回馈赛专用) """ def __init__(self, table): self.table = table self._tableRank = 0 self._nextGroupTimer = None def clearTimer(self): if self._nextGroupTimer: self._nextGroupTimer.cancel() self._nextGroupTimer = None def initGroup(self, tableRank): """初始化倍率鱼群""" self._tableRank = tableRank self._setNextGroupTimer() def _setNextGroupTimer(self): """启动倍率鱼定时器""" self.clearTimer() interval = random.randint(25, int((1 - self._tableRank) * 30 + 30)) self._nextGroupTimer = FTLoopTimer(interval, 0, self._addMultipleFishGroup) self._nextGroupTimer.start() def _addMultipleFishGroup(self): """添加倍率鱼群""" randomNum = random.randint(1, 10000) for multipleFishMap in config.getRandomMultipleFishConf( self.table.runConfig.fishPool): probb = multipleFishMap["probb"] if probb[0] <= randomNum <= probb[-1]: fishType = multipleFishMap["fishType"] allMultipleGroupIds = self.table.runConfig.allMultipleGroupIds groupId = random.choice(allMultipleGroupIds[fishType]) if ftlog.is_debug(): ftlog.debug("_addMultipleFishGroup", fishType, allMultipleGroupIds, groupId) self.table.insertFishGroup(groupId) self._setNextGroupTimer() break def cancelNextGroupTimer(self): """取消定时器""" if self._nextGroupTimer: self._nextGroupTimer.cancel() self._nextGroupTimer = None
def _sendTaskInfo(self): """ 发送任务倒计时信息 """ ftlog.debug("sendCmpttTaskInfo =", self.showCmpttInfo) # 发送夺宝赛倒计时信息 if self.showCmpttInfo and self._cmpttTask: cmpttTimer = FTLoopTimer(1, 0, self._cmpttTask.sendCmpttTaskInfo) cmpttTimer.start() ftlog.debug("sendBonusTaskInfo =", self.showBonusInfo) # 发送奖金池倒计时信息 if self.showBonusInfo and self._bonusTask: bonusTimer = FTLoopTimer(1, 0, self._bonusTask.sendBonusTaskInfo) bonusTimer.start()
class SportOdds(object): '''欧指筛选''' ODDS = ['17', '308', '255', '256', '254'] def __init__(self, sportlottery): self.sportlottery = sportlottery self.timer = FTLoopTimer(10, -1, self._getHttpOdds) self.timer.start() if ftlog.is_debug(): ftlog.debug('SportOdds', 'sportObj=', self.sportlottery.toDict()) def _getHttpOdds(self): if ftlog.is_debug(): ftlog.debug('SportOdds', '_getHttpOdds=', self.sportlottery.toDict()) contents = http7Mgethdaoddsinfo(self.sportlottery.matchId) if not contents or len(contents) == 0: return if contents.get('GameId') != str(self.sportlottery.matchId): ftlog.warn('SportOdds httpOdds GameId not match', 'matchId=', self.sportlottery.matchId, 'GameId=', contents.get('GameId')) return Datas = contents.get('Datas') if not Datas or len(Datas) == 0: ftlog.warn('SportOdds httpOdds Datas empty', 'Datas=', Datas, 'contents=', contents) return tag = 0 for data in Datas: if data.get('Cid') in self.ODDS: odds = data.get('Data', []) if odds and len(odds) >= 3: self.sportlottery.odds = odds[:3] self.sportlottery.save() if self.timer: self.timer.cancel() tag = 1 break if self.sportlottery and tag == 1: self.sportlottery.clearSportOdds()
def _checkUserConditionNew(self, userId): """ 检查个人可见奖券鱼出现条件是否满足 """ userCouponFishConf = config.getUserCouponFishConf( self.table.runConfig.fishPool) groupId, interval, totalBullet = self._isAppearUserCouponFishNew( userId, userCouponFishConf) if groupId: timer = FTLoopTimer(interval, 0, self._addUserCouponFishGroupNew, groupId, userId, totalBullet) timer.start() self._playerCouponTimerDict[userId] = timer if ftlog.is_debug(): ftlog.debug("_checkUserConditionNew->userId =", userId, "groupId =", groupId, "interval =", interval, "totalBullet =", totalBullet, "tableId =", self.table.tableId)
def _addTerrorFishGroup(self, userId): """ 添加Terror鱼 """ if ftlog.is_debug(): ftlog.debug("_addTerrorFishGroup", userId, self.table.tableId) player = self.table.getPlayer(userId) if player and player.taskSystemUser: taskId = player.taskSystemUser.getCurMainTaskId() newbieFishGroupConf = config.getPublic("newbieFishGroupConf", {}) terrorFishGroups = newbieFishGroupConf.get(str(taskId), {}).get( "terrorFishGroups", []) data = self._playerTerrorTimerDict.get(userId) if terrorFishGroups and (not data or data[1].getTimeOut() <= 0): group = self.table.insertFishGroup( random.choice(terrorFishGroups), userId=userId, sendUserId=userId) timer = FTLoopTimer(120, 0, self._addTerrorFishGroup, userId) timer.start() self._playerTerrorTimerDict[userId] = [group, timer]
def _setAutofillFishTimer(self): """ 设置自动填充鱼的定时器 """ for idx, fishConf in enumerate(self.autofillFishConf): self.fishTypeList.append( [fish["fishType"] for fish in fishConf["fish"]]) interval = random.randint(fishConf["minInterval"], fishConf["maxInterval"]) # 自动添加鱼的时间间隔 fishTimer = FTLoopTimer(interval, 0, self._addAutofillFishGroup, idx) fishTimer.start() self._nextTimerList.append(fishTimer) supplyInterval = fishConf["supplyInterval"] # 补充鱼时间间隔 checkTimer = FTLoopTimer(max(3, supplyInterval), -1, self._checkFishTypeCount, idx) checkTimer.start() self._checkCountTimerList.append(checkTimer) if ftlog.is_debug(): ftlog.debug("_setAutofillFishTimer", "tableId =", self.table.tableId, self.fishTypeList)
def _addSharkFishGroup(self, userId): """ 添加大白鲨 """ player = self.table.getPlayer(userId) if player and player.taskSystemUser: taskId = player.taskSystemUser.getCurMainTaskId() if ftlog.is_debug(): ftlog.debug("_addSharkFishGroup", userId, self.table.tableId, taskId) newbieFishGroupConf = config.getPublic("newbieFishGroupConf", {}) sharkFishGroups = newbieFishGroupConf.get(str(taskId), {}).get( "sharkFishGroups", []) data = self._playerSharkTimerDict.get(userId) if sharkFishGroups and (not data or data[1].getTimeOut() <= 0): group = self.table.insertFishGroup( random.choice(sharkFishGroups), userId=userId, sendUserId=userId) timer = FTLoopTimer(group.totalTime + 1, 0, self._addSharkFishGroup, userId) timer.start() self._playerSharkTimerDict[userId] = [group, timer]
class GrandPrixFishGroup(object): """ grandprix鱼群 """ def __init__(self, table): self._fishTypes = config.getGrandPrixConf("group").values() self._interval = 60 self.table = table self._idx = 0 self._nextGrandPrixTimer = None self._setGrandPrixTimer() def clearTimer(self): """清理定时器""" if self._nextGrandPrixTimer: self._nextGrandPrixTimer.cancel() self._nextGrandPrixTimer = None def _setGrandPrixTimer(self): """设置大奖赛定时器""" self._idx = 0 self.clearTimer() self._nextGrandPrixTimer = FTLoopTimer(self._interval, -1, self._addGrandPrixFishGroup) self._nextGrandPrixTimer.start() def _addGrandPrixFishGroup(self): """增加大奖赛鱼群""" for _val in self._fishTypes: _fishType = _val[self._idx % len(_val)] if _fishType in self.table.runConfig.allGrandPrixGroupIds: grandPrixGroupIds = self.table.runConfig.allGrandPrixGroupIds[ _fishType] if grandPrixGroupIds: grandPrixGroupId = random.choice(grandPrixGroupIds) self.table.insertFishGroup(grandPrixGroupId) # 召唤大奖赛鱼群 self._idx += 1
class FishGrandPrixPlayer(FishMultiplePlayer): def _loadUserData(self): super(FishGrandPrixPlayer, self)._loadUserData() # 捕鱼积分 self.grandPrixFishPoint = weakdata.getDayFishData( self.userId, WeakData.grandPrix_fishPoint, 0) # 大奖赛剩余开火次数 self.grandPrixFireCount = weakdata.getDayFishData( self.userId, WeakData.grandPrix_fireCount, 0) # 大奖赛剩余技能使用次数 self.grandPrixUseSkillTimes = weakdata.getDayFishData( self.userId, WeakData.grandPrix_useSkillTimes, []) # 大奖赛目标鱼捕获数量 self.grandPrixTargetFish = weakdata.getDayFishData( self.userId, WeakData.grandPrix_targetFish, {}) # 大奖赛火炮等级和倍率 # self.grandPrixLevelFpMultiple = weakdata.getDayFishData(self.userId, WeakData.grandPrix_levelFpMultiple) # 大奖赛开始的时间戳 self.grandPrixStartTS = weakdata.getDayFishData( self.userId, WeakData.grandPrix_startTS, 0) # 大奖赛结束定时器 self.grandPrixEndTimer = None # 大奖赛提示定时器 self.grandPrixTipTimer = None # 大奖赛阶段奖励 self.grandPrixGetPointsInfo = weakdata.getDayFishData( self.userId, WeakData.grandPrix_getPointsInfo, []) self._freeTimes = weakdata.getDayFishData(self.userId, WeakData.grandPrix_freeTimes, 0) self.multipleList = [] # 10、50、200、500 for v in gdata.roomIdDefineMap().values(): roomConf = v.configure if roomConf.get("typeName") not in [config.FISH_FRIEND]: continue self.multipleList.append(roomConf.get("multiple", 1)) self.multipleList.sort() self._rankListCache = [] # 超越玩家的集合 self._surpassUser = {} self.grandPrixSurpassCount = weakdata.getDayFishData( self.userId, WeakData.grandPrix_surpassCount, 0) # 大奖赛超越自己次数 self.bestPoint = weakdata.getDayFishData(self.userId, WeakData.grandPrix_point, 0) self.inGameTimes = 0 # 游戏时长(分钟) def _incrGameTimer(self): """增加游戏时长""" if self.userId <= 0: return super(FishGrandPrixPlayer, self)._incrGameTimer() self.inGameTimes += 1 def _checkSkillCondition(self, skillId, select, skillType=0): """ 检测技能使用条件 """ if self.isGrandPrixMode() and select: # 大奖赛模式限制技能槽的使用次数 for idx, val in enumerate(self.grandPrixUseSkillTimes): if val.get("skillId") == skillId and val.get("skillType", 0) == skillType: if val.get("count") <= 0: return 7 break return super(FishGrandPrixPlayer, self)._checkSkillCondition(skillId, select, skillType) def addFire(self, bulletId, wpId, sendTimestamp, fpMultiple, gunMultiple=1, gunX=1, skill=None, power=None, clientFire=True, targetPos=None, fishType=None, costChip=0, superBullet=None): """添加开火信息""" super(FishGrandPrixPlayer, self).addFire(bulletId, wpId, sendTimestamp, fpMultiple, gunMultiple, gunX, skill, power, clientFire, targetPos, fishType, costChip, superBullet) if clientFire and skill is None and self.isGrandPrixMode(): self.grandPrixFireCount -= 1 # 开火次数减少 if self.grandPrixFireCount == 0: # 结束比赛 self.endGrandPrix() def _refreshSkillSlots(self, skillType=0): """ 刷新技能数据 安装技能槽 """ if skillType == 0: self.skillSlots = {} if self.grandPrixUseSkillTimes: for val in self.grandPrixUseSkillTimes: if isinstance(val, dict) and val.get("skillId"): if val.get("skillType", 0) == skillType: if skillType == 0: self.skillSlots[val["skillId"]] = [ val["state"], val["star"], val["grade"] ] else: super(FishGrandPrixPlayer, self)._refreshSkillSlots(skillType) def clearTimer(self): """清理提示和结束的定时器""" super(FishGrandPrixPlayer, self).clearTimer() if self.grandPrixEndTimer: self.grandPrixEndTimer.cancel() self.grandPrixEndTimer = None if self.grandPrixTipTimer: self.grandPrixTipTimer.cancel() self.grandPrixTipTimer = None if self.inGameTimes: bireport.reportGameEvent("BI_NFISH_GRAND_PRIX_INGAMETIMES", self.userId, FISH_GAMEID, 0, 0, self.grandPrixStartTS, self.inGameTimes, 0, 0, [], util.getClientId(self.userId)) def checkCanFire(self, fPos, wpId, bulletId, skillId, skillType): """ 检测玩家是否可以开火 """ canFire, reason, clip, costBullet, extends, skill = \ super(FishGrandPrixPlayer, self).checkCanFire(fPos, wpId, bulletId, skillId, skillType) if canFire and self.isGrandPrixMode() and self.grandPrixFireCount <= 0: canFire, reason = False, 8 return canFire, reason, clip, costBullet, extends, skill def sendFireMsg(self, userId, seatId, extends, params): """ 发送开火确认消息 """ fPos = params.get("fPos") wpId = params.get("wpId") bulletId = params.get("bulletId") skillId = params.get("skillId") timestamp = params.get("timestamp") canFire = params.get("canFire") reason = params.get("reason") clip = params.get("clip") skillType = params.get("skillType", 0) lockFId = params.get("lockFId", 0) fPosx, fPosy = fPos retMsg = MsgPack() retMsg.setCmd("fire") retMsg.setResult("gameId", FISH_GAMEID) retMsg.setResult("userId", userId) retMsg.setResult("wpId", wpId) retMsg.setResult("bulletId", bulletId) retMsg.setResult("skillId", skillId) retMsg.setResult("skillType", skillType) retMsg.setResult("extends", extends) retMsg.setResult("timestamp", timestamp) retMsg.setResult("reason", reason) retMsg.setResult("grandPrixFireCount", self.grandPrixFireCount) # 大奖赛剩余开火次数 retMsg.setResult("clip", clip) retMsg.setResult("lockFId", lockFId) superBullet = self.getFire(bulletId).get( "superBullet", {}) # self.isSuperBullet(bulletId) retMsg.setResult("superBullet", 1 if superBullet else 0) # 测试代码 GameMsg.sendMsg(retMsg, userId) if canFire: retMsg.setResult("fPosx", fPosx) retMsg.setResult("fPosy", fPosy) retMsg.setResult("seatId", seatId) GameMsg.sendMsg(retMsg, self.table.getBroadcastUids(userId)) def saveUserData(self): """保存用户数据""" super(FishGrandPrixPlayer, self).saveUserData() self.saveGrandPrixPoint() # 保存大奖赛积分 def getTargetFishs(self): """ 返回目标鱼(魔术炮技能召唤使用) """ fishes = super(FishGrandPrixPlayer, self).getTargetFishs() targetFish = [ int(ft) for ft, val in self.grandPrixTargetFish.iteritems() if val[0] < val[1] ] # 0 < 5目标鱼数量 if targetFish: fishes.extend(targetFish) return fishes def getMatchingFpMultiple(self, fpMultiple): """ 获取玩家渔场倍率对应的基础倍率 """ multiple = self.table.runConfig.multiple for mul in self.multipleList: if fpMultiple >= mul: multiple = mul return multiple def isGrandPrixMode(self): """ 大奖赛比赛模式 """ return self.grandPrixStartTS > 0 def _calcuCatchFishGrandPrixPoint(self, fishPoint, gunX): """ 计算捕鱼积分 炮倍和vip的加成 """ if ftlog.is_debug(): ftlog.debug('calcuCatchFishGrandPrixPoint', fishPoint, gunX) vipAddition = config.getVipConf(self.vipLevel).get( "grandPrixAddition", 0.) gunXAddition = self.getGunXAddition(gunX) if ftlog.is_debug(): ftlog.debug('calcuCatchFishGrandPrixPoint1', vipAddition, gunXAddition) point = fishPoint * 100 points = point * (1 + vipAddition) * (1 + gunXAddition) return int(points) def getGunXAddition(self, gunX): """ 根据开火时候[炮倍 * 炮(单倍率|双倍率)]确定 加成值 """ gunMInfo = config.getGrandPrixConf("gunMultiAddition") for info in gunMInfo: if info["rangeList"][0] <= gunX <= info["rangeList"][1]: return info["addition"] return 0 def saveGrandPrixPoint(self): """ 保存大奖赛积分 """ if not self.isGrandPrixMode(): return 0, 0 grandPrixFinalPoint = self.grandPrixFishPoint # 计入排行榜 if grandPrixFinalPoint: ranking_system.refreshGrandPrixPoint(self.userId, grandPrixFinalPoint) # 保存大奖赛数据 self._saveGrandPrixData() return int(grandPrixFinalPoint) # 最后的积分 def cancelUsingSkills(self): """ 取消处于使用中的技能 """ if not self.usingSkill: # 有之前技能记录 return lastSkillId = self.usingSkill[-1].get("skillId") lastSkillType = self.usingSkill[-1].get("skillType", 0) lastSkill = self.getSkill(lastSkillId, lastSkillType) if not lastSkill: return if lastSkill.state == 1: lastSkill.use(0) else: self.removeUsingSkill(lastSkillId, lastSkillType) orgState = lastSkill.state lastSkill.state = 0 self.table.broadcastSkillUse(lastSkill, 0, self.userId, orgState) # 广播选中/取消技能消息 self.table.broadcastGunChange(self) # 广播玩家现在的火炮等级 def unloadSkills(self): """ 下载所有技能 """ for _skillId in self.skills.keys(): _skill = self.getSkill(_skillId, 0) if not _skill: continue _skill.clear() del _skill def startGrandPrix(self): """ 大奖赛开始 grandPrixStartTS=0 报名大奖赛/ grandPrixStartTS > 0 直接进入渔场 """ curTime = int(time.time()) dayStartTimestamp = util.getDayStartTimestamp(curTime) remainGrandPrixTimeSeconds = util.timeStrToInt( config.getGrandPrixConf("openTimeRange")[1]) - ( curTime - dayStartTimestamp) # 大奖赛剩余时间 # 当局进入大奖赛 if self.grandPrixStartTS == 0: event = JoinGrandPrixEvent(self.userId, FISH_GAMEID, self.table.bigRoomId) # 参加大奖赛事件 TGFish.getEventBus().publishEvent(event) # 距离大奖赛结束不足10秒不可参赛 if not grand_prix.isGrandPrixOpenTime( ) or remainGrandPrixTimeSeconds < 10: code = SignupCode.SC_NOT_OPEN elif config.getVipConf(self.vipLevel).get( "grandPrixFreeTimes", 0) > self._freeTimes: # 用免费次数报名 self._freeTimes = weakdata.incrDayFishData( self.userId, WeakData.grandPrix_freeTimes, 1) code = SignupCode.SC_SUCC else: # 扣除报名费 fee = config.getGrandPrixConf("fee")[0] _consume = [{ "name": fee.get("name"), "count": fee.get("count") }] _ret = util.consumeItems(self.userId, _consume, "ITEM_USE", self.table.roomId) if _ret: code = SignupCode.SC_SUCC else: code = SignupCode.SC_FEE_NOT_ENOUGH if code == SignupCode.SC_SUCC: # 选择目标鱼 for _val in config.getGrandPrixConf( "group").values(): # 1、2、3个组 idx = random.randint(0, len(_val) - 1) # 一组鱼 _cnt = config.getGrandPrixConf("target").get( str(_val[idx]), {}).get("count", 999) # 某一种鱼 捕获数量 _point = config.getGrandPrixConf("target").get( str(_val[idx]), {}).get("point", 0) # 某一种鱼 获得的积分 self.grandPrixTargetFish[str( _val[idx])] = [0, _cnt, _point] # 备份技能数据. self.grandPrixUseSkillTimes = [] for i in range(skill_system.MAX_INSTALL_NUM - 1): self.grandPrixUseSkillTimes.append({ "skillId": 0, "state": 0, "star": 0, "grade": 0, "count": config.getGrandPrixConf("fireCount")[1], # 技能使用次数3 "skillType": 0 if i < skill_system.MAX_INSTALL_NUM else 1 # 0主技能 1辅助技能 }) for idx, _skillId in enumerate(self.skillSlots): _skill = self.getSkill(_skillId, 0) self.grandPrixUseSkillTimes[idx]["skillId"] = _skillId self.grandPrixUseSkillTimes[idx][ "state"] = _skill.skillState self.grandPrixUseSkillTimes[idx]["star"] = _skill.skillStar self.grandPrixUseSkillTimes[idx][ "grade"] = _skill.skillGrade if self.inGameTimes: bireport.reportGameEvent("BI_NFISH_GRAND_PRIX_INGAMETIMES", self.userId, FISH_GAMEID, 0, 0, self.grandPrixStartTS, self.inGameTimes, 0, 0, [], util.getClientId(self.userId)) self.inGameTimes = 0 self.grandPrixFishPoint = 0 self.grandPrixSurpassCount = 0 self.grandPrixStartTS = curTime # 大奖赛开始的时间戳 self.grandPrixFireCount = config.getGrandPrixConf( "fireCount")[0] self._saveGrandPrixData() # 保存大奖赛数据 else: if not grand_prix.isGrandPrixOpenTime(): # 现在不可参赛 code = SignupCode.SC_NOT_OPEN elif not self.isGrandPrixMode(): code = SignupCode.SC_SUCC else: code = SignupCode.SC_UNFINISH if code in [SignupCode.SC_SUCC, SignupCode.SC_UNFINISH]: interval = max(0.1, remainGrandPrixTimeSeconds) if self.grandPrixFireCount == 0: # 3秒之后结束大奖赛 interval = 0.1 if self.grandPrixEndTimer: self.grandPrixEndTimer.cancel() self.grandPrixEndTimer = None self.grandPrixEndTimer = FTLoopTimer(interval, 0, self.endGrandPrix) # 启动结束定时器 self.grandPrixEndTimer.start() # 取消处于使用中的技能,以免干扰技能使用次数计数 if self.offline == 0: # 玩家在线 self.cancelUsingSkills() self.unloadSkills() self.loadAllSkillData() self.syncSkillSlots() elif code == SignupCode.SC_NOT_OPEN: # 没开启 self._resetGrandPrixData() # 重置大奖赛相关数据 self._getSurpassTarget() # 获取要超越的玩家数据 mo = MsgPack() mo.setCmd("start_grand_prix") mo.setResult("gameId", FISH_GAMEID) mo.setResult("userId", self.userId) mo.setResult("seatId", self.seatId) mo.setResult("fireCount", self.grandPrixFireCount) mo.setResult("fishPoint", self.grandPrixFishPoint) mo.setResult("targetFish", self.grandPrixTargetFish) mo.setResult( "useSkillTimes", { val.get("skillId", 0): val.get("count", 0) for val in self.grandPrixUseSkillTimes }) mo.setResult("pointsInfo", grand_prix.getPointInfo( self.userId)) # 奖励积分 道具Id、道具数量、是否领取了奖励0|1 mo.setResult("todayMaxPoints", weakdata.getDayFishData(self.userId, WeakData.grandPrix_point, 0)) # 今日最高积分 GameMsg.sendMsg(mo, self.userId) def endGrandPrix(self): """ 大奖赛结束 """ if self.userId == 0: return if self.grandPrixEndTimer: self.grandPrixEndTimer.cancel() self.grandPrixEndTimer = None if not self.isGrandPrixMode(): return grandPrixFinalPoint = self.saveGrandPrixPoint() # 完成大奖赛事件 event = FinishGrandPrixEvent(self.userId, FISH_GAMEID, self.table.bigRoomId, grandPrixFinalPoint) TGFish.getEventBus().publishEvent(event) bireport.reportGameEvent("BI_NFISH_GRAND_PRIX_END", self.userId, FISH_GAMEID, 0, 0, grandPrixFinalPoint, 0, 0, 0, [], util.getClientId(self.userId)) if self.inGameTimes: bireport.reportGameEvent("BI_NFISH_GRAND_PRIX_INGAMETIMES", self.userId, FISH_GAMEID, 0, 0, self.grandPrixStartTS, self.inGameTimes, 0, 0, [], util.getClientId(self.userId)) self.inGameTimes = 0 self.cancelUsingSkills() # 恢复技能数据 取消处于使用中的技能 self.unloadSkills() # 下载所有技能 self._resetGrandPrixData() # 重置数据存档 self.loadAllSkillData() # 重新加载技能 读取并初始化所有技能数据 self.syncSkillSlots() # 同步技能槽消息 rank, rankRewards = ranking_system.getUserRankAndRewards( RankType.TodayGrandPrix, self.userId) if ftlog.is_debug(): ftlog.debug("endGrandPrix", self.grandPrixStartTS, self.grandPrixFireCount, self.grandPrixFishPoint) mo = MsgPack() mo.setCmd("end_grand_prix") mo.setResult("gameId", FISH_GAMEID) mo.setResult("userId", self.userId) mo.setResult("seatId", self.seatId) mo.setResult("fishPoint", grandPrixFinalPoint) mo.setResult("rank", rank) mo.setResult("rankRewards", rankRewards) mo.setResult("fee", config.getGrandPrixConf("fee")) mo.setResult( "tabs", ranking_system.getRankingTabs(self.userId, util.getClientId(self.userId), RankType.TodayGrandPrix, rankDetail=True)) GameMsg.sendMsg(mo, self.userId) self.sendGrandPrixInfo() self.table.clearPlayer(self) # 从桌子中踢掉玩家 def _resetGrandPrixData(self): """ 重置大奖赛相关数据 """ self.grandPrixStartTS = 0 # 大奖赛开始的时间戳 self.grandPrixFireCount = 0 # 大奖赛剩余开火次数 self.grandPrixTargetFish = {} # 大奖赛目标鱼捕获数量 self.grandPrixUseSkillTimes = [] # 大奖赛剩余技能使用次数 self.grandPrixFishPoint = 0 # 捕鱼积分 self.grandPrixSurpassCount = 0 # 大奖赛超越自己次数 # self.grandPrixLevelFpMultiple = None # 大奖赛火炮等级和倍率 self._rankListCache = [] # 要超越的玩家缓存 self._surpassUser = {} # 要超越玩家数据 self._saveGrandPrixData() # 保存大奖赛信息 weakdata.setDayFishData(self.userId, WeakData.grandPrix_surpassCount, 0) # 大奖赛超越自己次数 def _saveGrandPrixData(self): """ 保存大奖赛数据 """ weakdata.setDayFishData(self.userId, WeakData.grandPrix_startTS, self.grandPrixStartTS) weakdata.setDayFishData(self.userId, WeakData.grandPrix_fireCount, self.grandPrixFireCount) weakdata.setDayFishData(self.userId, WeakData.grandPrix_fishPoint, self.grandPrixFishPoint) weakdata.setDayFishData(self.userId, WeakData.grandPrix_surpassCount, self.grandPrixSurpassCount) weakdata.setDayFishData(self.userId, WeakData.grandPrix_useSkillTimes, json.dumps(self.grandPrixUseSkillTimes)) weakdata.setDayFishData(self.userId, WeakData.grandPrix_targetFish, json.dumps(self.grandPrixTargetFish)) # weakdata.setDayFishData(self.userId, WeakData.grandPrix_levelFpMultiple, json.dumps(self.grandPrixLevelFpMultiple)) def sendGrandPrixInfo(self): """ 发送大奖赛信息 大奖赛相关信息(进入渔场后服务器主动推送) """ if not grand_prix.isGrandPrixOpenTime(): # 是否为大奖赛开放时段 00:00 —— 23:00 self._resetGrandPrixData() self._freeTimes = 0 # 免费次数 weakdata.setDayFishData(self.userId, WeakData.grandPrix_getPointsInfo, json.dumps([])) weakdata.setDayFishData(self.userId, WeakData.grandPrix_freeTimes, self._freeTimes) if ftlog.is_debug(): ftlog.debug("sendGrandPrixInfo", self.grandPrixStartTS, self.isGrandPrixMode()) signUpState = 1 if self.isGrandPrixMode() else 0 # 是否已经报名 remainFreeTimes = config.getVipConf(self.vipLevel).get( "grandPrixFreeTimes", 0) - self._freeTimes # 剩余免费次数 openTime = "-".join(config.getGrandPrixConf("openTimeRange")) # 时间范围 mo = MsgPack() mo.setCmd("grand_prix_info") mo.setResult("gameId", FISH_GAMEID) mo.setResult("userId", self.userId) mo.setResult("seatId", self.seatId) mo.setResult("remainFreeTimes", remainFreeTimes) mo.setResult("fee", config.getGrandPrixConf("fee")) # 报名费 mo.setResult("openTime", openTime) # 00:00 - 23:00 mo.setResult( "isInOpenTime", 1 if grand_prix.isGrandPrixOpenTime() else 0) # 大奖在是否在开放时间段 mo.setResult("signUpState", signUpState) # 是否已报名大奖赛 mo.setResult( "todayRankType", RankType.TodayGrandPrix) # 今日榜Type,使用fish_ranking获取排行榜数据,下同 mo.setResult("todayDate", util.timestampToStr(int(time.time()), "%m/%d")) # 今日榜时间 mo.setResult("yesterdayRankType", RankType.LastGrandPrix) mo.setResult("yesterdayDate", util.timestampToStr(int(time.time() - 86400), "%m/%d")) mo.setResult( "des", config.getMultiLangTextConf( config.getGrandPrixConf("info").get("des"), lang=self.lang)) # 每日积分超过2400送100珍珠,今日榜单每10分钟刷新1次,最终排名00:00公布 mo.setResult("pointsInfo", grand_prix.getPointInfo( self.userId)) # 奖励积分 道具Id、道具数量、是否领取了奖励0|1 mo.setResult("todayMaxPoints", weakdata.getDayFishData(self.userId, WeakData.grandPrix_point, 0)) # 今日最高积分 GameMsg.sendMsg(mo, self.userId) if ftlog.is_debug(): ftlog.debug("FishGrandPrixPlayer, userId =", self.userId, "mo =", mo) def addGrandPrixFishPoint(self, fishPoint, fishType, gunX): """ 添加大奖赛捕鱼积分 """ if self.isGrandPrixMode(): fishPoint = self._calcuCatchFishGrandPrixPoint( fishPoint, gunX) # 计算捕获 vip加成 + 火炮倍率加成 self.grandPrixFishPoint += fishPoint fishType = int(fishType) % 100 for ft, val in self.grandPrixTargetFish.iteritems(): # 添加目标鱼积分 if fishType == int(ft) % 100 and val[0] < val[1]: self.grandPrixTargetFish[ft][0] += 1 if self.grandPrixTargetFish[ft][0] == val[1]: self.grandPrixFishPoint += val[2] break if self.grandPrixFishPoint > self.bestPoint: # 最好的积分 self.grandPrixSurpassCount += 1 # 大奖赛超越自己次数 self._surpassTarget() else: fishPoint = 0 return fishPoint def getPointReward(self, userId): """ 是否获取积分阶段奖励 """ rewards = [] for info in config.getGrandPrixConf("stageInfo"): point = info["point"] reward = info["rewards"] if self.grandPrixFishPoint >= point and point not in self.grandPrixGetPointsInfo: rewards.extend(reward) self.grandPrixGetPointsInfo.append(point) if rewards: util.addRewards(userId, rewards, "BI_GRAND_PRIX_POINT_REWARD") # 添加奖励 weakdata.setDayFishData(userId, WeakData.grandPrix_getPointsInfo, json.dumps(self.grandPrixGetPointsInfo)) return rewards def sendGrandPrixCatch(self, catchFishPoints): """ 大奖赛捕获消息 """ mo = MsgPack() mo.setCmd("catch_grand_prix") mo.setResult("gameId", FISH_GAMEID) mo.setResult("userId", self.userId) mo.setResult("seatId", self.seatId) mo.setResult("catchFishPoints", catchFishPoints) # [{"fId": 10010, "point": 5},], # 捕鱼积分 mo.setResult("fishPoint", self.grandPrixFishPoint) # 捕鱼积分 mo.setResult("targetFish", self.grandPrixTargetFish ) # {"11011": [0, 10],}, # 大奖赛目标鱼:[捕获数量, 目标数量] mo.setResult( "rewards", self.getPointReward(self.userId) ) # [{"name": 101, "count": 1000}, {"name": 101, "count": 2000}], # 大奖赛积分奖励 mo.setResult("pointsInfo", grand_prix.getPointInfo( self.userId)) # 奖励积分 道具Id、道具数量、是否领取了奖励0|1 GameMsg.sendMsg(mo, self.userId) def setTipTimer(self): """ 设置比赛开始和结束的通知消息 """ if self.grandPrixTipTimer: self.grandPrixTipTimer.cancel() self.grandPrixTipTimer = None self.sendGrandPrixInfo() # 发送大奖赛信息 curTime = int(time.time()) dayStartTS = util.getDayStartTimestamp(curTime) openTimeRange = config.getGrandPrixConf("openTimeRange") pastTime = curTime - dayStartTS # 03:00|23:10 beginTime = util.timeStrToInt(openTimeRange[0]) # 00:00 endTime = util.timeStrToInt(openTimeRange[1]) # 23:00 if pastTime < beginTime: interval = beginTime - pastTime + 5 # 开始的通知 elif beginTime <= pastTime <= endTime: interval = endTime - pastTime + 5 # 结束的通知 else: interval = 86400 + beginTime - pastTime + 5 # 开始的通知 self.grandPrixTipTimer = FTLoopTimer(interval, 0, self.setTipTimer) # 死循环 self.grandPrixTipTimer.start() def _getSurpassTarget(self): """ 获取要超越的玩家数据 """ timestamp = pktimestamp.getCurrentTimestamp() rankClass = RankingBase(self.userId, RankType.TodayGrandPrix, RankDefineIndex.GrandPrix, clientId=None, httpRequest=False) if rankClass: rankingList = rankClass.getTopNRankUsers(timestamp) surpassTarget = config.getGrandPrixConf( "surpassTarget") # [100、80、... 3、2、1] masterSurpassTargets = [] for rank in surpassTarget: idx = rank - 1 if 0 <= idx < len(rankingList.rankingUserList): player = rankingList.rankingUserList[idx] name = util.getNickname(player.userId) avatar = userdata.getAttr(player.userId, "purl") masterSurpassTargets.append({ "userId": player.userId, "name": name, "score": player.score, "rank": player.rank + 1, "avatar": avatar }) self._rankListCache = masterSurpassTargets def _surpassTarget(self): """请求大奖赛中超越玩家数据""" if self.userId: msg = MsgPack() msg.setCmd("g_surpass") msg.setResult("gameId", FISH_GAMEID) msg.setResult("roomId", self.table.roomId) msg.setResult("tableId", self.table.tableId) msg.setResult("userId", self.userId) if self.grandPrixSurpassCount <= 1 and self.bestPoint != 0: msg.setResult("bestScore", self.grandPrixFishPoint) if self._surpassUser.get(self.userId, None): if self.grandPrixFishPoint > self._surpassUser.get( self.userId).get("score"): msg.setResult("target", self._surpassUser.get(self.userId)) if self.grandPrixSurpassCount <= 1 or self._surpassUser.get( self.userId, None): GameMsg.sendMsg(msg, self.userId) self._updateSurpassUser() def _updateSurpassUser(self): """更新要超越的目标用户""" newTarget = None maxScore = max(self.grandPrixFishPoint, self.bestPoint) for tar in self._rankListCache: if maxScore < tar["score"] and tar["userId"] != self.userId: newTarget = tar break self._surpassUser[self.userId] = newTarget
class TaskBase(object): def __init__(self, player, taskConf, taskSystem, taskData=None): self.player = player self.userId = player.userId self.taskId = taskConf["taskId"] self.taskConfig = taskConf self.taskSystem = taskSystem self.taskData = taskData or self._getInitMainData() self.taskInterval = taskConf["timeLong"] self.helpProgress = taskData.get("helpProgress", 0) if taskData else 0 self.waitTime = taskData.get("waitTime", 0) if taskData else taskConf["waitTime"] self.taskActivateTimer = None # 任务激活 self.sendTaskInfoTimer = None # 发送任务信息 self.updateTaskInfoTimer = None # 刷新任务进度 self.userEndTaskTimer = None # 任务结束倒计时 self.isSendMsg = False self.receiveRewards = None self.catchBetNum = taskData.get("catchBetNum", 0) if taskData else 0 self._reload() def clear(self): """清理定时器""" if self.taskActivateTimer: self.taskActivateTimer.cancel() if self.sendTaskInfoTimer: self.sendTaskInfoTimer.cancel() if self.updateTaskInfoTimer: self.updateTaskInfoTimer.cancel() if self.userEndTaskTimer: self.userEndTaskTimer.cancel() def _reload(self): self.recordStartTime = 0 if not self.isTaskOver(): if self.taskData.get("type", 0) and self.taskData.get("type", 0) != self.taskConfig["type"]: self.taskData = self._getInitMainData() return if self.taskConfig["target"] != self.taskData["target"]: # 未完成的任务任务目标发生变化后重置存档 self.taskData = self._getInitMainData() return if self.taskConfig["targetNum"] != self.taskData["targetNum"] and self.taskData.get("type", 0) not in [0, TaskType.HoldCoin]: self.taskData = self._getInitMainData() return def _getInitMainData(self): """获取初始化主线数据""" targetNum = self.taskConfig["targetNum"] if util.isNewbieRoom(self.player.table.typeName) and self.taskConfig["type"] == TaskType.HoldCoin: targetNum += self.player.allChip // 100 * 100 return { "type": self.taskConfig["type"], "progress": 0, "state": TaskState.NotOpen, "failTime": 0, "targetNum": targetNum, "target": self.taskConfig["target"] } def _addProgress(self, value, isMe, progress=0, isTargetAddition=False): """增加任务进度""" assert (self.taskData) if value == 0 or self.taskData["state"] != TaskState.Update: # value return if ftlog.is_debug(): ftlog.debug("_addProgress1", "value =", value, "isMe =", isMe, "progress =", progress, "isTargetAddition =", isTargetAddition, "helpProgress =", self.helpProgress) if isMe: value *= self.taskSystem.taskExpedite progress_ = min(self.taskData["progress"] + value, 999999999999) self._updateProgress(progress_, isMe) else: if progress > 0 or isTargetAddition: if progress: self.helpProgress += progress else: self.helpProgress += value progress_ = min(self.taskData["progress"] + value, 999999999999) self._updateProgress(progress_, isMe) if ftlog.is_debug(): ftlog.debug("_addProgress2", "helpProgress =", self.helpProgress, "totalProgress =", progress_) def _updateProgress(self, value, isMe): """ 更新任务进度 """ if self.taskData["progress"] != value: self.taskData["progress"] = value self.taskData["time"] = int(time.time()) if self._isComplete(): self.taskEnd() else: if isMe: self.sendUserTaskInfo() else: # 好友助力任务进度延迟刷新 self.isSendMsg = True def _receiveTaskReward(self): """领取奖励""" assert (self.taskData) if self.isTaskOver(): # 已领取 return 1, None targetCount = self.taskData["targetNum"] if self.taskData["progress"] < targetCount: # 未达成 return 1, None _rewards = self._getDropItems() if not _rewards: _rewards = self.taskConfig["rewards"] # 普通奖励 if _rewards and util.isChestRewardId(_rewards[0]["name"]): # 宝箱奖励(新手宝箱奖励固定) if util.isNewbieRoom(self.player.table.typeName): _rewards = [ {"name": 101, "count": 500}, {"name": 1145, "count": 1}, {"name": 1149, "count": 1} # {"name": 1137, "count": 3} ] else: from newfish.entity.chest import chest_system _rewards = chest_system.getChestRewards(self.userId, _rewards[0]["name"]) rewards = [] for _, reward in enumerate(_rewards): if reward["name"] <= 0: continue rwDict = {} rwDict["name"] = reward["name"] rwDict["count"] = reward["count"] rewards.append(rwDict) code = 0 self.taskData["state"] = TaskState.Success # 改变状态 if rewards: code = util.addRewards(self.userId, rewards, "BI_NFISH_TABLE_TASK_REWARDS", int(self.taskId)) return code, rewards def _getDropItems(self): """获取掉落的道具""" realRewards = [] rewards = self.taskConfig["rewards"] for reward in rewards: dropId = reward["name"] dropConf = config.getDropConf(dropId) if dropConf: _, rds = drop_system.getDropItem(dropId) realRewards.append(rds) return realRewards def _getCatchFishCoin(self, event, target=0): """获取捕鱼的金币""" totalCoin = 0 # 总金币数不包括招财珠 gunSkinMul = event.gunSkinMul fishCoins = {} outCoinsNum = 0 for gainMap in event.gain: fishType = int(gainMap["fishType"]) itemId = gainMap["itemId"] itemCount = gainMap["count"] / gunSkinMul if itemId == config.CHIP_KINDID: # 金币 totalCoin += itemCount if fishType // 1000 == 14: fishType = fishType % 14000 + 11000 fishCoins[str(fishType)] = fishCoins.setdefault(str(fishType), 0) + itemCount if target and itemCount >= target: outCoinsNum += 1 return totalCoin, fishCoins, outCoinsNum def dealCatchEvent(self, event, tableMultiple, coinAddition, playersNum): """ 处理捕鱼事件 :param event: 捕获事件详情 :param tableMultiple: 房间倍率 :param coinAddition: 当处于累计捕获金币任务时的进度加成 :param playersNum: 当前桌内玩家数量 :return: """ if self.taskConfig["type"] in [TaskType.UseSkillNum, TaskType.ComboNum]: return if self.taskData["state"] != TaskState.Update: return isMe = event.userId == self.userId fishTypes = event.fishTypes # 鱼种类 wpId = event.wpId gunSkinMul = event.gunSkinMul target = self.taskConfig["target"] progress = 0 isTargetAddition = False if self.taskConfig["type"] in [TaskType.CatchFishCoin, TaskType.UseSkillCatchFishCoin]: progress = coinAddition elif self.taskConfig["type"] in [TaskType.CatchFishNum, TaskType.CatchBossNum, TaskType.FishNumCoinHigh, TaskType.BetFishNum, TaskType.CatchRainbowFishNum, TaskType.CatchRedPacketFishNum]: friendHelpPlayerMultiple = config.getCommonValueByKey("friendHelpPlayerMultiple", {}).get(str(playersNum - 1), 0) probb = (friendHelpPlayerMultiple * (self.taskData["targetNum"] + 5) / self.taskData["targetNum"]) * 10000 randInt = random.randint(1, 10000) if randInt <= probb: isTargetAddition = True if self.taskConfig["type"] == TaskType.CatchFishCoin: # 1捕获xx鱼达金币数 totalCoin, fishCoins, _ = self._getCatchFishCoin(event) if target: self._addProgress(fishCoins.get(str(target), 0), isMe, progress=progress, isTargetAddition=isTargetAddition) else: self._addProgress(totalCoin, isMe, progress=progress, isTargetAddition=isTargetAddition) elif self.taskConfig["type"] == TaskType.CatchFishNum: # 2捕获鱼个数 if target: betTarget = 14000 + int(target) % 11000 fishNum = fishTypes.count(target) + fishTypes.count(betTarget) self._addProgress(fishNum, isMe, progress=progress, isTargetAddition=isTargetAddition) else: self._addProgress(len(fishTypes), isMe, progress=progress, isTargetAddition=isTargetAddition) return elif self.taskConfig["type"] == TaskType.CatchBossNum: # 3捕获boss个数 bossNum = 0 # boss个数 for fishType in fishTypes: fishConf = config.getFishConf(fishType, self.taskSystem.table.typeName, tableMultiple) if fishConf["type"] in config.BOSS_FISH_TYPE: bossNum += 1 self._addProgress(bossNum, isMe, progress=progress, isTargetAddition=isTargetAddition) return elif self.taskConfig["type"] == TaskType.FishNumCoinHigh: # 4多少金币以上的鱼 _, _, num = self._getCatchFishCoin(event, target) self._addProgress(num, isMe, progress=progress, isTargetAddition=isTargetAddition) return elif self.taskConfig["type"] == TaskType.BetFishNum: # 5--多少只倍率鱼 betFishMap = {} for gainMap in event.gain: fishConf = config.getFishConf(gainMap["fishType"], self.taskSystem.table.typeName, tableMultiple) itemId = gainMap["itemId"] itemCount = gainMap["count"] if fishConf["type"] in config.MULTIPLE_FISH_TYPE: if itemId == config.CHIP_KINDID: # 金币 bet = itemCount / fishConf["score"] / tableMultiple / gunSkinMul betFishMap[str(bet)] = betFishMap.get(str(bet), 0) + 1 betNum = 0 for bet in betFishMap: if int(bet) >= target: betNum += betFishMap[bet] self._addProgress(betNum, isMe, progress=progress, isTargetAddition=isTargetAddition) elif self.taskConfig["type"] == TaskType.UseSkillCatchFishNum: # 8 使用技能捕获鱼数 wpType = util.getWeaponType(wpId) if wpType in [config.SKILL_WEAPON_TYPE, config.RB_FIRE_WEAPON_TYPE, config.RB_BOMB_WEAPON_TYPE]: if target: self._addProgress(fishTypes.count(target), isMe, progress=progress, isTargetAddition=isTargetAddition) else: self._addProgress(len(fishTypes), isMe, progress=progress, isTargetAddition=isTargetAddition) elif self.taskConfig["type"] == TaskType.UseSkillCatchFishCoin: # 9 使用技能捕获XX金币类型的鱼数 totalCoin, fishCoins, _ = self._getCatchFishCoin(event) # 总金币数不包括招财珠 wpType = util.getWeaponType(wpId) if wpType in [config.SKILL_WEAPON_TYPE, config.RB_FIRE_WEAPON_TYPE, config.RB_BOMB_WEAPON_TYPE]: if target: self._addProgress(fishCoins.get(str(target), 0), isMe, progress=progress, isTargetAddition=isTargetAddition) else: self._addProgress(totalCoin, isMe, progress=progress, isTargetAddition=isTargetAddition) elif self.taskConfig["type"] == TaskType.CatchFishNumByOneFire: # 10 1网捕获多少鱼 if len(fishTypes) >= target: value = 1 if not isMe: return self._addProgress(value, isMe, progress=progress, isTargetAddition=isTargetAddition) elif self.taskConfig["type"] == TaskType.CatchRainbowFishNum: # 捕获彩虹鱼 rainbowNum = 0 for fishType in fishTypes: fishConf = config.getFishConf(fishType, self.taskSystem.table.typeName, tableMultiple) if fishConf["type"] in config.RAINBOW_FISH_TYPE: rainbowNum += 1 self._addProgress(rainbowNum, isMe, progress=progress, isTargetAddition=isTargetAddition) elif self.taskConfig["type"] == TaskType.CatchRedPacketFishNum: # 捕获红包券鱼 redPacketNum = 0 for fishType in fishTypes: fishConf = config.getFishConf(fishType, self.taskSystem.table.typeName, tableMultiple) if fishConf["type"] == 4: redPacketNum += 1 self._addProgress(redPacketNum, isMe, progress=progress, isTargetAddition=isTargetAddition) def dealUseSkillEvent(self, event): """使用技能事件""" if self.taskData["state"] != TaskState.Update: return if self.taskConfig["type"] == TaskType.UseSkillNum: target = self.taskConfig["target"] if target == 0: self._addProgress(1, event.userId == self.userId) else: if event.skillId == target: self._addProgress(1, event.userId == self.userId) def dealUseSkillItem(self, event): """使用技能道具""" if self.taskData["state"] != TaskState.Update: return if self.taskConfig["type"] == TaskType.UserSkillItem: self._addProgress(1, event.userId == self.userId) def dealGetPearl(self, pearl): """获得珍珠""" if self.taskData["state"] != TaskState.Update: return if self.taskConfig["type"] == TaskType.CatchPearlNum: self._addProgress(pearl, True) def dealCommboEvent(self, event): """处理连击事件""" if self.taskData["state"] != TaskState.Update: return if self.taskConfig["type"] == TaskType.ComboNum: if event.comboNum >= self.taskConfig["target"]: self._addProgress(1, event.userId == self.userId) def refreshHoldCoin(self, coin): """刷新持有金币数量""" if self.taskData["state"] != TaskState.Update: return if ftlog.is_debug(): ftlog.debug("refreshHoldCoin", self.userId, coin) if self.taskConfig["type"] == TaskType.HoldCoin: self._updateProgress(coin, True) def refreshLevel(self, level): """刷新等级""" if self.taskData["state"] != TaskState.Update: return ftlog.debug("refreshLevel", self.userId, level) if self.taskConfig["type"] == TaskType.UpgradeLevel: self._updateProgress(level, True) def getTaskId(self): """ 获取任务Id """ return self.taskId def taskStart(self, interval=0, delay=0): """ 任务开始 """ if ftlog.is_debug(): ftlog.debug("taskBase_______taskStart", self.taskId) if self.taskActivateTimer: self.taskActivateTimer.cancel() if delay > 0: taskActivateInterval = max(interval, Task_Delay_Ready_Time) self.taskActivateTimer = FTLoopTimer(taskActivateInterval, 0, self._taskActivate, delay) self.taskActivateTimer.start() elif self.taskConfig["timeLong"] > 0: if util.isNewbieRoom(self.player.table.typeName) and self.taskSystem.taskModel == TaskModel.Main: time_ = Task_Red_Ready_Time else: time_ = Task_Normal_Ready_Time taskActivateInterval = max(interval, time_) taskInfoInterval = max(interval - time_, 0) self.delaySendUserTaskInfo(taskInfoInterval) self.taskActivateTimer = FTLoopTimer(taskActivateInterval, 0, self._taskActivate) self.taskActivateTimer.start() else: self.taskActivateTimer = FTLoopTimer(interval, 0, self._taskActivate) self.taskActivateTimer.start() from newfish.game import TGFish from newfish.entity.event import TableTaskStartEvent event = TableTaskStartEvent(self.userId, FISH_GAMEID, self.taskSystem.table.tableId, self.getTaskId()) TGFish.getEventBus().publishEvent(event) def _taskActivate(self, delay=0): """任务激活""" # 未完成前3个中期目标时不触发渔场任务. if self.taskSystem.needCheckMidTermTargetStates: if not self.taskSystem.top3MidTermTargetFinished: self.taskSystem.top3MidTermTargetFinished = True for taskClass in self.player.achieveSystem.holdAssetTasks: if taskClass.taskId < 1003 or (taskClass.taskId == 1003 and not taskClass.isComplete()): self.taskSystem.top3MidTermTargetFinished = False break if not self.taskSystem.top3MidTermTargetFinished: if self.taskActivateTimer: self.taskActivateTimer.cancel() self.taskActivateTimer = FTLoopTimer(60, 0, self._taskActivate) self.taskActivateTimer.start() if ftlog.is_debug(): ftlog.debug("_taskActivate, need delay !", self.player.userId, self.taskId) return if ftlog.is_debug(): ftlog.debug("_taskActivate->", delay, self.waitTime) self.taskData["state"] = TaskState.Start if delay > 0: self.taskData["state"] = TaskState.Update self.taskInterval = delay self.recordStartTime = int(time.time()) self.clear() if self.taskInterval != 0: self.userEndTaskTimer = FTLoopTimer(self.taskInterval, 0, self.taskEnd) self.userEndTaskTimer.start() if self.taskSystem.isFriendRoom(): self.updateTaskInfoTimer = FTLoopTimer(1, -1, self.sendTimerUpdate) self.updateTaskInfoTimer.start() self.sendUserTaskInfo() self.taskData["state"] = TaskState.Update def getTaskFailTime(self): """ 当前任务已经失败多少次 """ return self.taskData["failTime"] def getTaskInfo(self): """ 获取返回给客户端的任务数据 """ progress = min(self.taskData["progress"], self.taskData["targetNum"]) progress = int(progress) if progress - int(progress) == 0 else progress meProgress = progress - self.helpProgress meProgress = int(meProgress) if meProgress - int(meProgress) == 0 else meProgress taskInfo = {} taskInfo["taskId"] = self.taskConfig["taskId"] taskInfo["isLimitTime"] = self.isLimitTime() taskInfo["shareMode"] = 1 # 1 if not self.isLimitTime() or util.isLocationLimit(self.userId) else 0 taskInfo["progress"] = [int(progress), int(meProgress), self.taskData["targetNum"]] taskInfo["state"] = self.taskData["state"] taskInfodescId = self.taskConfig["desc"] taskInfo["desc"] = config.getMultiLangTextConf(str(taskInfodescId), lang=util.getLanguage(self.userId)) taskInfo["reward"] = self.taskConfig["rewards"] if self.receiveRewards: taskInfo["realReward"] = self.receiveRewards taskInfo["target"] = self.taskConfig["target"] taskInfo["suggestTarget"] = self.taskConfig["suggestTarget"] timeLeft = self.recordStartTime + self.taskInterval - int(time.time()) taskInfo["timeLeft"] = timeLeft if timeLeft >= 0 else self.taskInterval taskInfo["timeLong"] = self.taskInterval taskInfo["failTimeConf"] = self.taskConfig["failTime"] taskInfo["failTime"] = self.taskData["failTime"] # 失败次数 taskInfo["isNextLimitTime"] = self.taskSystem.isNextLimitTime(self.getTaskId()) taskInfo["model"] = TaskModel.Red if util.isNewbieRoom(self.player.table.typeName) and self.taskSystem.taskModel == TaskModel.Main else self.taskSystem.taskModel taskInfo["type"] = self.taskConfig["type"] if self.taskSystem.taskModel in [TaskModel.Red, TaskModel.Main]: taskInfo["index"] = self.taskSystem.allMainTaskIds.index(self.taskId) return taskInfo def getTaskData(self): """ 获取存储的任务数据 """ saveData = {} saveData["type"] = self.taskConfig["type"] saveData["taskId"] = self.taskId saveData["progress"] = self.taskData["progress"] saveData["helpProgress"] = self.helpProgress saveData["state"] = self.taskData["state"] saveData["target"] = self.taskConfig["target"] saveData["targetNum"] = self.taskData["targetNum"] saveData["failTime"] = self.taskData["failTime"] saveData["waitTime"] = int(self.taskActivateTimer.getTimeOut()) if self.taskActivateTimer else 0 if self.catchBetNum: saveData["catchBetNum"] = self.catchBetNum return saveData def taskEnd(self): """ 任务结束 """ if ftlog.is_debug(): ftlog.debug("taskBase_______taskEnd", self.taskId, self.userId, self.taskData["state"]) beforeState = self.taskData["state"] self.clear() if beforeState == TaskState.Update: isComplete = self._isComplete() if isComplete: _, rewards = self._receiveTaskReward() self.receiveRewards = rewards self.taskSystem.saveRedState() # 保存红包 else: self.taskSystem.taskExpedite = 1 self.taskData["state"] = TaskState.Fail if self.isLimitTime(): self.taskData["failTime"] += 1 from newfish.game import TGFish from newfish.entity.event import TableTaskEndEvent event = TableTaskEndEvent(self.userId, FISH_GAMEID, self.taskSystem.table.tableId, self.getTaskId(), isComplete, self.isLimitTime(), self.receiveRewards) TGFish.getEventBus().publishEvent(event) # 上传当前完成任务进度 if self.taskSystem.taskModel == TaskModel.Main and self.taskSystem.isRedRoom(): ftlog.debug("BI_NFISH_THOUSAND_RED_TASK_PROGRESS--->000", self.getTaskId()) bireport.reportGameEvent("BI_NFISH_GE_THOUSAND_RED_TASK", self.userId,FISH_GAMEID, self.taskSystem.table.roomId, self.taskSystem.table.tableId, self.getTaskId(), int(isComplete), 0, 0, [], config.CLIENTID_ROBOT) # 新手引导步骤完成 if self.taskConfig["type"] == TaskType.UpgradeLevel: util.addGuideStep(self.player.userId, config.NEWBIE_GUIDE_GUN_UP, self.player.clientId) self.sendUserTaskInfo() def sendTimerUpdate(self): """ 任务进度刷新 """ if self.taskConfig["type"] == TaskType.HoldCoin: self.taskSystem.refreshHoldCoin(self.player.holdCoin) elif self.taskConfig["type"] == TaskType.UpgradeLevel: gunLevel = self.player.gunLevel - 2100 self.taskSystem.refreshLevel(gunLevel) if self.isSendMsg: self.sendUserTaskInfo() def delaySendUserTaskInfo(self, interval=0): """ 延时发送任务信息 """ if self.sendTaskInfoTimer: self.sendTaskInfoTimer.cancel() self.sendTaskInfoTimer = FTLoopTimer(interval, 0, self.sendUserTaskInfo) self.sendTaskInfoTimer.start() def sendUserTaskInfo(self): """ 发送任务信息 """ self.isSendMsg = False message = MsgPack() message.setCmd("table_task_info") message.setResult("gameId", FISH_GAMEID) message.setResult("userId", self.userId) taskInfo = self.getTaskInfo() message.setResult("taskInfo", taskInfo) router.sendToUser(message, self.userId) def _isComplete(self): """ 任务是否完成 """ assert (self.taskData) targetCount = self.taskData["targetNum"] return self.taskData["progress"] >= targetCount def isTaskSuccess(self): """ 任务成功 """ return self.taskData["state"] == TaskState.Success def getTaskConf(self): assert (self.taskConfig) return self.taskConfig def isTaskOver(self): """任务结束""" return self.taskData["state"] in [TaskState.Success, TaskState.Fail] def getTaskState(self): return self.taskData["state"] def getTaskTargets(self): if self.taskData["state"] != TaskState.Update: return [] if self.taskConfig["type"] in [TaskType.CatchFishNum, TaskType.CatchFishCoin, TaskType.UseSkillCatchFishNum, TaskType.UseSkillCatchFishCoin]: if self.taskConfig["target"] != 0: return [self.taskConfig["target"]] return [] def isLimitTime(self): """是否限制了时间""" if not self.taskConfig: return 0 return 1 if self.taskConfig.get("timeLong", 0) != 0 else 0
class CmpttTask(TableMatchTask): """ 竞争性任务(夺宝赛) """ def __init__(self, table, taskName, taskInterval): super(CmpttTask, self).__init__(table, taskName, taskInterval) self._reload() def _reload(self): self.currentTask = {} self.userIds = [] self.usersData = {} self.state = 0 self.catchId = 100000000 self.rewardType = 0 self.recordStartTime = 0 self.sendInfoTime = 60 self.chestRewardId = 0 # self.readyTimer = FishTableTimer(self.table) self.startTimer = FishTableTimer(self.table) self.endTimer = FishTableTimer(self.table) self.sendInfoTimer = None # self.readyTimer.setup(self.taskInterval, "task_ready", {"task": self.taskName}) self.recordReloadTime = time.time() self.taskId = "%d-%d" % (self.table.tableId, 0) def clear(self): """ 清除所有公共数据 """ self.currentTask = {} self.userIds = [] self.usersData = {} self.state = 0 self.recordStartTime = 0 self.recordReloadTime = 0 # if self.readyTimer: # self.readyTimer.cancel() if self.startTimer: self.startTimer.cancel() if self.endTimer: self.endTimer.cancel() if self.sendInfoTimer: self.sendInfoTimer.cancel() def taskReady(self, *args): """ 任务准备 """ self.state = 1 if self.sendInfoTimer: self.sendInfoTimer.cancel() tasks = config.getCmpttTaskConf(self.table.runConfig.fishPool) if len(tasks) == 0 or len(self.table.getBroadcastUids()) == 0: endTimer = FishTableTimer(self.table) endTimer.setup(0, "task_end", {"uid": 0, "task": self.taskName}) return self.taskId = "%d-%d" % (self.table.tableId, int(time.time())) randTask = random.choice(tasks) self.currentTask = copy.deepcopy(randTask) for uid in self.table.getBroadcastUids(): if util.isFinishAllNewbieTask(uid): self.userIds.append(uid) if len(self.userIds) <= 2: self.chestRewardId = self.currentTask["chestReward"][0] elif len(self.userIds) == 3: self.chestRewardId = self.currentTask["chestReward"][1] elif len(self.userIds) >= 4: self.chestRewardId = self.currentTask["chestReward"][2] for uid in self.userIds: self.usersData[uid] = { "uid": uid, "task": self.currentTask, "score": 0, "results": {}, "lastCatchId": 0 } readySeconds = self.currentTask["readySeconds"] msg = MsgPack() msg.setCmd("cmptt_task") msg.setResult("gameId", FISH_GAMEID) msg.setResult("action", "ready") msg.setResult("taskId", self.currentTask["taskId"]) msg.setResult("taskType", self.currentTask["taskType"]) msg.setResult("targets", self.currentTask["targets"]) msg.setResult("reward", {"name": self.chestRewardId, "count": 1}) GameMsg.sendMsg(msg, self.userIds) self.startTimer.setup(readySeconds, "task_start", {"task": self.taskName}) def taskStart(self, *args): """ 任务开始 """ if not self.currentTask: return 0 self.state = 2 self.rewardType = 1 # if len(self.userIds) in [1, 2]: # self.rewardType = 4 # 宝箱+珍珠 # elif len(self.userIds) == 3: # self.rewardType = 3 # 宝箱+金币 # elif len(self.userIds) == 4: # self.rewardType = random.choice([3, 5]) # 宝箱+金币or宝箱+奖券 for userId in self.userIds: player = self.table.getPlayer(userId) if player: self.sendCmpttTaskStartInfo(userId, self.currentTask["timeLong"]) task = copy.deepcopy(self.currentTask) player.currentTask = [ self.taskName, task["taskId"], task["taskType"], task["targets"] ] self.recordStartTime = int(time.time()) self.endTimer.setup(self.currentTask["timeLong"], "task_end", {"task": self.taskName}) return self.currentTask["taskId"] def taskEnd(self, *args, **kwargs): """ 任务结束 """ if self.state == 0: self.clear() return self.state = 0 _taskId = 0 if self.currentTask: _taskId = self.currentTask["taskId"] ranks = kwargs.get("ranks") if not ranks: ranks = self._getRanks() reward = False dropItems = None player = None rewardDropId = 0 rewardItem = 0 if ranks: usersData = self.usersData.get(ranks[1]["uid"]) if self._checkFinished(usersData): reward = True player = self.table.getPlayer(ranks[1]["uid"]) dropItems = self._sendTaskReward(player, self.chestRewardId, self.userIds) # 夺宝赛获奖 from newfish.game import TGFish from newfish.entity.event import WinCmpttTaskEvent event = WinCmpttTaskEvent(player.userId, FISH_GAMEID, self.table.roomId, self.table.tableId) TGFish.getEventBus().publishEvent(event) msg = MsgPack() msg.setCmd("cmptt_task") msg.setResult("gameId", FISH_GAMEID) msg.setResult("action", "finish") msg.setResult("taskId", self.currentTask["taskId"]) msg.setResult("taskType", self.currentTask["taskType"]) msg.setResult("ranks", ranks) if reward and player: msg.setResult("reward", dropItems) GameMsg.sendMsg(msg, self.userIds) self.clearTaskData() if _taskId and self.table.ttAutofillFishGroup: self.table.ttAutofillFishGroup.endAutofill(0, _taskId) def clearTaskData(self, uid=None): """ 清除用户任务数据 """ if uid: player = self.table.getPlayer(uid) if player: player.currentTask = None if uid in self.userIds: self.userIds.remove(uid) if uid in self.usersData: del self.usersData[uid] if self.state == 0 or len(self.userIds) == 0: for userId in self.userIds: player = self.table.getPlayer(userId) if player: player.currentTask = None self.clear() def sendCmpttTaskInfo(self): """ 发送夺宝赛任务倒计时信息 """ userIds = [] for uid in self.table.getBroadcastUids(): if util.isFinishAllNewbieTask(uid): userIds.append(uid) if self.sendInfoTimer: self.sendInfoTimer.cancel() if not userIds: return if self.state == 0: self.sendInfoTimer = FTLoopTimer(self.sendInfoTime, 0, self.sendCmpttTaskInfo) self.sendInfoTimer.start() else: return timeLeft = int( self.taskInterval) - int(time.time() - self.recordReloadTime) if timeLeft <= 0: return msg = MsgPack() msg.setCmd("cmptt_task") msg.setResult("gameId", FISH_GAMEID) msg.setResult("action", "info") msg.setResult("timeLeft", timeLeft) GameMsg.sendMsg(msg, userIds) def sendCmpttTaskStartInfo(self, userId, timeLeft): """ 发送夺宝赛开始消息 """ msg = MsgPack() msg.setCmd("cmptt_task") msg.setResult("gameId", FISH_GAMEID) msg.setResult("action", "start") msg.setResult("taskId", self.currentTask["taskId"]) desc = config.getMultiLangTextConf(str(self.currentTask["desc"]), lang=util.getLanguage(userId)) if desc.find("%d") >= 0: desc = desc % self.currentTask["targets"].get("number1", 0) msg.setResult("desc", desc) msg.setResult("timeLeft", timeLeft) msg.setResult("timeLong", self.currentTask["timeLong"]) msg.setResult("taskType", self.currentTask["taskType"]) msg.setResult("rewardType", self.rewardType) msg.setResult("targets", self.currentTask["targets"]) msg.setResult("reward", {"name": self.chestRewardId, "count": 1}) GameMsg.sendMsg(msg, userId) def newJoinTask(self, userId): """ 新加入任务 """ if self.state == 0: return self.userIds.append(userId) self.usersData[userId] = { "uid": userId, "task": copy.deepcopy(self.currentTask), "score": 0, "results": {}, "lastCatchId": 0 } def newJoinTaskForAfterTheStart(self, userId): """ 任务开始后结束前新加入任务 """ if self.state != 2: return if userId is None or len(self.userIds) == 0: return timeLeft = int( self.currentTask["timeLong"]) - int(time.time() - self.recordStartTime) if timeLeft <= 10: return self.newJoinTask(userId) # 发送开始消息,给出任务剩余时间 self.sendCmpttTaskStartInfo(userId, timeLeft) # 发送排名信息 self._sendRanksInfo() # 设置用户当前任务信息 player = self.table.getPlayer(userId) if player: task = copy.deepcopy(self.currentTask) player.currentTask = [ self.taskName, task["taskId"], task["taskType"], task["targets"] ] def sendTaskInfoForReconnect(self, userId): """ 用户断线重连发送任务相关信息 """ if self.state != 2: return timeLeft = int( self.currentTask["timeLong"]) - int(time.time() - self.recordStartTime) if timeLeft <= 5: return self.sendCmpttTaskStartInfo(userId, timeLeft) self._sendRanksInfo() def _sendTaskReward(self, player, chestId, broadcastUserIds): """ 发送任务奖励 """ chestRewards = chest_system.getChestRewards(player.userId, chestId) util.addRewards(player.userId, chestRewards, "BI_NFISH_CMPTT_TASK_REWARDS", roomId=self.table.roomId, tableId=self.table.tableId) from newfish.game import TGFish from newfish.entity.event import GainChestEvent from newfish.entity.chest.chest_system import ChestFromType event = GainChestEvent(player.userId, FISH_GAMEID, chestId, ChestFromType.Cmptt_Ncmptt_Bonus_Task) TGFish.getEventBus().publishEvent(event) dropItems = {"chest": chestId, "chestRewards": chestRewards, "type": 0} return dropItems def _sendRanksInfo(self): """ 发送排名信息 """ if self.currentTask: msg = MsgPack() msg.setCmd("cmptt_task") msg.setResult("gameId", FISH_GAMEID) msg.setResult("action", "rank") msg.setResult("taskId", self.currentTask["taskId"]) msg.setResult("taskType", self.currentTask["taskType"]) msg.setResult("ranks", self._getRanks()) GameMsg.sendMsg(msg, self.userIds) def dealLeaveTable(self, event): """ 处理离开事件 """ if self.state == 0: return uid = event.userId self.clearTaskData(uid) self._sendRanksInfo() def dealCatchEvent(self, event): """ 处理捕获事件 """ if self.state != 2: return uid = event.userId fishTypes = event.fishTypes if uid not in self.userIds: return fpMultiple = self.getEventFpMultiple(event) score = 0 player = self.table.getPlayer(uid) usersData = self.usersData.get(uid) taskType = usersData["task"]["taskType"] targets = usersData["task"]["targets"] target1 = targets.get("target1", 0) target2 = targets.get("target2", 0) multipleTarget1 = 14000 + target1 % 11000 multipleTarget2 = 14000 + target2 % 11000 number1 = targets.get("number1", 999) number2 = targets.get("number2", 999) if taskType != 1 and "progress" not in usersData["results"]: usersData["results"]["progress"] = 0 if taskType == 1: # 指定数量特定鱼 if target1 not in fishTypes and target2 not in fishTypes and multipleTarget1 not in fishTypes and multipleTarget2 not in fishTypes: return if (target1 in fishTypes or multipleTarget1 in fishTypes) and target1 not in usersData["results"]: usersData["results"][target1] = 0 if (target2 in fishTypes or multipleTarget2 in fishTypes) and target2 not in usersData["results"]: usersData["results"][target2] = 0 if self._checkFinished(usersData): return if player and player.currentTask: if target1 in fishTypes or multipleTarget1 in fishTypes: target1Score = fishTypes.count(target1) + fishTypes.count( multipleTarget1) if usersData["results"][target1] + target1Score >= number1: score += (number1 - usersData["results"][target1]) usersData["results"][target1] = number1 if player.currentTask[3].has_key("target1"): player.currentTask[3].pop("target1") else: score += target1Score usersData["results"][target1] += target1Score if target2 in fishTypes or multipleTarget2 in fishTypes: target2Score = fishTypes.count(target2) + fishTypes.count( multipleTarget2) if usersData["results"][target2] + target2Score >= number2: score += (number2 - usersData["results"][target2]) usersData["results"][target2] = number2 if player.currentTask[3].has_key("target2"): player.currentTask[3].pop("target2") else: score += target2Score usersData["results"][target2] += target2Score elif taskType == 2: # 指定分数 for fishType in fishTypes: fishConf = config.getFishConf(fishType, self.table.typeName, fpMultiple) if fishConf.get("itemId", 0) in config.BULLET_KINDIDS: score += ( fishConf.get("score", 0) * config.BULLET_KINDIDS[fishConf.get("itemId", 0)] / fpMultiple) else: score += fishConf.get("score", 0) usersData["results"]["progress"] += score usersData["score"] += score if score == 0: return usersData["lastCatchId"] = self.catchId self.catchId -= 1 self._sendRanksInfo() if self._checkFinished(usersData): self.endTimer.cancel() self.taskEnd(ranks=self._getRanks()) return def _getRanks(self): """ 获得排名信息 """ udatas = self.usersData.values() if udatas: udatas.sort(key=lambda x: (x["score"], x["lastCatchId"]), reverse=True) ranks = {} for m in xrange(len(udatas)): if udatas[m]["score"] == 0: continue ranks[m + 1] = { "uid": udatas[m]["uid"], "results": udatas[m]["results"] } return ranks def _checkFinished(self, usersData): """ 检查是否完成任务 """ results = usersData["results"] taskType = usersData["task"]["taskType"] targets = usersData["task"]["targets"] target1 = targets.get("target1", 0) target2 = targets.get("target2", 0) number1 = targets.get("number1", 999) number2 = targets.get("number2", 999) finished = False if taskType == 1: if len(targets.keys()) == 3: # 一个target会对应有3个字段 if target1 in results.keys() and results[target1] >= number1: finished = True else: if target1 in results.keys() and results[target1] >= number1 and \ target2 in results.keys() and results[target2] >= number2: finished = True else: if usersData["results"].get("progress", 0) >= number1: finished = True return finished
class FishFightTable(FishTable): def __init__(self, room, tableId): super(FishFightTable, self).__init__(room, tableId) self.clearTableData() # 用户离线等待时间 self._offlineWaitSeconds = 1200 # 用户空闲超时时间 self._idleTimeOutSeconds = 1200 # 用户无子弹时超时时间 self._inactiveTimeOutSeconds = 1200 # 桌子过期时间 self._tableExpiresTime = 600 # 准备倒计时 self._readySeconds = 4 # 初始化定时器 self._expiresTimer = None self._readyTimer = None self._beginTimer = None # 最大人数 self.tableSeatCount = self.runConfig.matchConf["table.seat.count"] # table_call可用action self.actionMap = { "robot_leave": self._robotLeave, "catch": self._verifyCatch, "skill_use": self._skill_use, "skill_install": self._skill_install, "skill_replace": self._skill_replace, "smile": self.doTableSmilies, "honor_push": self._honor_push, "honor_replace": self._honor_replace, "guns_list": self._guns_list, "guns_pool": self._guns_pool, "ft_start": self.doFTStart, "ft_leave": self.doUserLeave, "treasure_rewards": self._getTreasureRewards } self._logger = Logger() self._logger.add("gameId", self.gameId) self._logger.add("roomId", room.roomId) self._logger.add("tableId", tableId) @property def ftId(self): return self.ftTable.ftId if self.ftTable else 0 @property def ftTable(self): return self._ftTable def clearTableData(self): """ 清理桌子数据和状态 """ if ftlog.is_debug(): ftlog.debug("friendTable.clear-->begin", "tableId=", self.tableId) self._tableState = TableState.DEFAULT # 桌子状态 # 桌子详情(房号、房主、服务费) self._ftTable = None self._beginTime = None self._usersData = {} self.targets = {} self.ftRanks = [] self.winnerId = None self.otherId = None self._overState = None if ftlog.is_debug(): ftlog.debug("friendTable.clear-->end", "tableId=", self.tableId) def clearAllTimer(self): """ 清理所有的计时器 """ if self._readyTimer: self._readyTimer.cancel() self._readyTimer = None if self._beginTimer: self._beginTimer.cancel() self._beginTimer = None if self._expiresTimer: self._expiresTimer.cancel() self._expiresTimer = None def createPlayer(self, table, seatIndex, clientId): """ 新创建Player对象 """ return FishFightPlayer(table, seatIndex, clientId) @locked def doFTEnter(self, ftId, userId, seatId): ftlog.info("FishFriendTable.doFTEnter", "tableId=", self.tableId, "ftId=", ftId, "seatId=", seatId) lang = util.getLanguage(userId) if ftId != self.ftId: raise TYBizException( 1, config.getMultiLangTextConf("ID_INPUT_ROOMID_ERROR_INFO", lang=lang)) player = self.getPlayer(userId) if player and player.userId: self.sendFriendDetails(userId) else: if self._expiresTimer: # 重置桌子超时计时器 self._expiresTimer.cancel() self._expiresTimer = None self._expiresTimer = FTLoopTimer(self._tableExpiresTime, 0, self._tableExpires) self._expiresTimer.start() self._doTableQuickStart(userId, seatId) # 用户进入 self.sendFriendDetails(userId) # 发送对战详情信息 if userId != self.ftTable.userId: # 记录参与者Id self.otherId = userId fight_history.addOneHistory(userId, self.ftTable.userId, fight_history.HistoryType.Enter, self.ftId, self.ftTable.fee) # 进入房间记录 return 0 def sendFriendDetails(self, userId): """发送好友竞技的详情""" self._updateFriendInfo(userId) self._updateFriendTask() if self._tableState >= TableState.READY: self._ftStart(userId) def _updateFriendInfo(self, userId): """更新好友消息""" ftPlayer = self.getPlayer(self.ftTable.userId) ftName = "" if ftPlayer: ftName = ftPlayer.name player = self.getPlayer(userId) if player and player.userId: msg = MsgPack() msg.setCmd("ft_info") msg.setResult("gameId", FISH_GAMEID) msg.setResult("roomId", self.roomId) msg.setResult("tableId", self.tableId) msg.setResult("seatId", player.seatId) msg.setResult("userId", player.userId) msg.setResult("tableState", self._tableState) msg.setResult("reward", self.ftTable.fee) msg.setResult("ftId", self.ftTable.ftId) msg.setResult("ftUserName", ftName) msg.setResult("ftUserId", self.ftTable.userId) msg.setResult("timeLong", self.runConfig.playingTime) msg.setResult( "expirseTime", int(self._expiresTimer.getTimeOut()) if self._expiresTimer else self._tableExpiresTime) msg.setResult("targets", self.targets) GameMsg.sendMsg(msg, player.userId) def _tableExpires(self): """桌子过期了""" if self._tableState < TableState.START: self._sendExpriseHistory() self._sendLeaveMsg(reason=1) self._clearTable()
class Heartbeat(object): ST_IDLE = 0 ST_START = 1 ST_STOP = 2 def __init__(self, target, interval): self._target = target self._state = Heartbeat.ST_IDLE self._count = 0 self._postTaskList = [] self._timer = None self._interval = interval self._logger = Logger() self._init = False def start(self): assert (self._state == Heartbeat.ST_IDLE) self._state = Heartbeat.ST_START self._timer = FTLoopTimer(0, 0, self._onInit) self._timer.start() def stop(self): if self._state != Heartbeat.ST_STOP: self._state = Heartbeat.ST_STOP if self._timer: self._timer.cancel() self._timer = None @property def count(self): return self._count def postCall(self, func, *args, **kwargs): self.postTask(functools.partial(func, *args, **kwargs)) def postTask(self, task): if self._state != Heartbeat.ST_STOP: self._postTaskList.append(task) if self._init and self._timer: self._timer.cancel() self._timer = FTLoopTimer(0, 0, self._onTimeout) self._timer.start() def _onInit(self): try: self._timer = None interval = self._target.onInit() if interval: self._interval = interval self._scheduleTimer() except: self._logger.error("Heartbeat._onInit") def _onTimeout(self): try: self._timer = None self._count += 1 self._processPostTaskList() interval = self._target.onHeartbeat() if interval is not None: self._interval = interval except: self._interval = 1 self._logger.error("Heartbeat._onTimeout") self._scheduleTimer() def _scheduleTimer(self): if self._state == Heartbeat.ST_START: interval = 0 if self._postTaskList else self._interval self._timer = FTLoopTimer(interval, 0, self._onTimeout) self._timer.start() def _processPostTaskList(self): taskList = self._postTaskList self._postTaskList = [] for task in taskList: try: task() except: self._logger.error("task=", task)
class ShortUrlx3me(object): def __init__(self, apiKey, secretKey): self.apiKey = apiKey self.secretKey = secretKey self.token = None self.expires = None self.refreshTimer = None def translate(self, longUrl): ''' 转换长url为短url @return: shortUrl ''' try: if self.isExpires(): self.token, self.expires = self.loadToken() return self._getShorUrl(longUrl) except: ftlog.error('ShortUrlx3me.translate', 'longUrl=', longUrl) return longUrl def initialize(self, serverType): if serverType == gdata.SRV_TYPE_CENTER: # 只在CT中执行刷新token的操作 self.refreshTimer = FTLoopTimer(300, -1, self._refreshTokenIfNeed) self.refreshTimer.start() FTLoopTimer(0, 0, self._refreshTokenIfNeed).start() else: self.refreshTimer = FTLoopTimer(300, -1, self._reloadToken) self.refreshTimer.start() self._reloadToken() def loadToken(self): jstr = None try: jstr = daobase.executeMixCmd('get', 'shortUrl.x3me:token') if jstr: d = strutil.loads(jstr) return d['token'], d['expires'] except: ftlog.error('ShortUrlx3me.getToken', 'jstr=', jstr) return None, None def saveToken(self, token, expires): d = {'token':token, 'expires':expires} jstr = strutil.dumps(d) daobase.executeMixCmd('set', 'shortUrl.x3me:token', jstr) def isExpires(self, timestamp=None): # 离过期时间1小时算过期 timestamp = timestamp or pktimestamp.getCurrentTimestamp() return not self.token or not self.expires or (timestamp + 3600) >= self.expires def _reloadToken(self): self.token, self.expires = self.loadToken() ftlog.info('ShortUrlx3me._reloadToken', 'token=', self.token, 'expires=', self.expires) def _refreshTokenIfNeed(self, timestamp=None): timestamp = timestamp or pktimestamp.getCurrentTimestamp() # 重新从数据库读取,可能数据库里面改变了(人工操作) self._reloadToken() # 提前一天刷新 if not self.token or (timestamp + 86400) >= self.expires: try: token, expires = self._requestToken() self.saveToken(token, expires) ftlog.info('ShortUrlx3me._refreshTokenIfNeed', 'old=', (self.token, self.expires), 'new=', (token, expires)) self.token, self.expires = token, expires except: ftlog.error('Failed to refresh token', 'old=', (self.token, self.expires)) def _requestToken(self): code = self._requestCode() return self._requestTokenWithCode(code) def _validResponse(self, response): datas = strutil.loads(response) return datas['status'], datas['info'], datas['data'] def _requestCode(self): response, _ = webpage.webget('https://0x3.me/apis/authorize/getCode', method_='GET') status, info, data = self._validResponse(response) if ftlog.is_debug(): ftlog.debug('ShortUrlx3me._requestCode', 'response=', response) if status != 1: ftlog.warn('ShortUrlx3me._requestCode', 'response=', response) raise TYBizException(-1, '%s:%s' % (status, info)) return data def _calcSign(self, params): kvs = [] for key in sorted(params.keys()): kvs.append('%s=%s' % (key, params[key])) kvs.append(self.secretKey) signstr = ''.join(kvs) return strutil.md5digest(signstr) def _requestTokenWithCode(self, code): timestr = datetime.now().strftime('%Y-%m-%d %H:%M:%S') params = {'api_key':self.apiKey, 'code':code, 'request_time':timestr} params['sign'] = self._calcSign(params) response, _ = webpage.webget('https://0x3.me/apis/authorize/getAccessToken', postdata_=params, method_='POST') status, info, data = self._validResponse(response) if status != 1: ftlog.warn('ShortUrlx3me._requestTokenWithCode', 'code=', code, 'response=', response) raise TYBizException(-1, '%s:%s' % (status, info)) return data['access_token'], int(data['expire_timestamp']) def _getShorUrl(self, longUrl): if not self.token: ftlog.warn('ShortUrlx3me._getShorUrl', 'err=', 'NoToken') return longUrl response, _ = webpage.webget('https://0x3.me/apis/urls/add', postdata_={'access_token':self.token, 'longurl':longUrl}, method_='POST') status, info, data = self._validResponse(response) if status != 1: raise TYBizException(-1, '%s:%s' % (status, info)) return data['short_url']
class DizhuCtrlRoomFriend(DizhuRoom, MsgHandler): def __init__(self, roomDefine): super(DizhuCtrlRoomFriend, self).__init__(roomDefine) self._ftMap = OrderedDict() self._tableCtrl = TableController() self._tableManager = self._buildTableManager() self._idleFTTimer = FTLoopTimer(60, -1, self._releaseIdleFT) self._idleFTTimer.start() ftlog.info('DizhuCtrlRoomFriend.DizhuCtrlRoomFriend Succ', 'roomId=', self.roomId, 'tableCount=', self._tableManager.allTableCount) def findFT(self, ftId): return self._ftMap.get(ftId) def createFT(self, userId, ftConf): from dizhu.friendtable import ft_service ftId = self._genFTId() if not ftId: raise TYBizException(-1, '资源不足') collectedFee = False # 收费 try: self._collectFee(userId, ftId, ftConf) collectedFee = True ft_service.ftBindRoomId(ftId, self.roomId) ftTable = FTTable( userId, ftId, ftConf, pktimestamp.getCurrentTimestamp(), pktimestamp.getCurrentTimestamp() + ft_service.getCreatorConf(userId).tableExpires) self._ftMap[ftId] = ftTable ftlog.info('DizhuCtrlRoomFriend.createFT Succ', 'roomId=', self.roomId, 'userId=', userId, 'ftId=', ftId, 'nRound=', ftConf.nRound, 'canDouble=', ftConf.canDouble, 'playMode=', ftConf.playMode, 'expires=', ftTable.expires, 'goodCard=', ftConf.goodCard, 'fee=', ftConf.fee.toDict() if ftConf.fee else None) return ftTable except: if collectedFee: self._returnFee(userId, ftId, ftConf) ft_service.releaseFTId(ftId) raise def continueFT(self, userId, ftId): # 收费 ftTable = self.findFT(ftId) if not ftTable: raise TYBizException(-2, '没有找到该牌桌') if ftTable.userId != userId: raise TYBizException(-3, '只有桌子主人才能继续') self._collectFee(userId, ftTable.ftId, ftTable.ftConf) from dizhu.friendtable import ft_service ftTable.expires = pktimestamp.getCurrentTimestamp( ) + ft_service.getCreatorConf(userId).tableExpires return ftTable def disbindFT(self, ftId, returnFee): from dizhu.friendtable import ft_service ftTable = self.findFT(ftId) if not ftTable: raise TYBizException(-1, '没有找到该牌桌') # 没有开始则退费 if not ftTable.table or returnFee: self._returnFee(ftTable.userId, ftId, ftTable.ftConf) del self._ftMap[ftId] if ftTable.table: self._tableManager.returnTable(ftTable.table) ft_service.releaseFTId(ftId) ftlog.info('DizhuCtrlRoomFriend.disbindFT Succ', 'roomId=', self.roomId, 'userId=', ftTable.userId, 'ftId=', ftTable.ftId, 'nRound=', ftTable.ftConf.nRound, 'canDouble=', ftTable.ftConf.canDouble, 'playMode=', ftTable.ftConf.playMode, 'fee=', ftTable.ftConf.fee.toDict() if ftTable.ftConf.fee else None) def enterFT(self, userId, ftId): ftTable = self.findFT(ftId) if not ftTable: raise TYBizException(-1, '没有找到该牌桌') # 绑定桌子 if not ftTable.table: if self._tableManager.idleTableCount < 1: raise TYBizException(-1, '桌子资源不足') table = self._tableManager.borrowTable() ftTable.table = table table._ftTable = ftTable ftlog.info('DizhuCtrlRoomFriend.enterFT BindTable', 'roomId=', self.roomId, 'userId=', userId, 'ftId=', ftTable.ftId, 'tableId=', ftTable.table.tableId) # 通知桌子绑定了朋友桌 self._tableCtrl.bindTable(ftTable.table) ec, info = self._tableCtrl.sitdown(ftTable.table, userId) if ec != 0: raise TYBizException(ec, info) ftlog.info('DizhuCtrlRoomFriend.enterFT Succ', 'roomId=', self.roomId, 'userId=', userId, 'ftId=', ftTable.ftId, 'tableId=', ftTable.table.tableId) return ftTable def _releaseIdleFT(self): if ftlog.is_debug(): ftlog.debug('DizhuCtrlRoomFriend._releaseIdleFT', 'roomId=', self.roomId) try: ftIds = [] timestamp = pktimestamp.getCurrentTimestamp() for ftId, ftTable in self._ftMap.iteritems(): if (timestamp - ftTable.createTime) >= 60: if not ftTable.table: ftIds.append(ftId) else: break for ftId in ftIds: try: self._ftMap.pop(ftId) ftlog.info('DizhuCtrlRoomFriend._releaseIdleFT', 'roomId=', self.roomId, 'ftId=', ftId, 'reason=', 'idleExpires') except: pass except: ftlog.error('DizhuCtrlRoomFriend._releaseIdleFT', 'roomId=', self.roomId) ftlog.info('DizhuCtrlRoomFriend._releaseIdleFT', 'roomId=', self.roomId, 'ftCount=', len(self._ftMap)) def _buildTableManager(self): shadowRoomIds = self.roomDefine.shadowRoomIds seatCount = self.tableConf.get('maxSeatN') ftlog.info('DizhuCtrlRoomFriend._buildTableManager', 'roomId=', self.roomId, 'shadowRoomIds=', list(shadowRoomIds), 'seatCount=', seatCount) tableManager = TableManager(self) for roomId in self.roomDefine.shadowRoomIds: count = self.roomDefine.configure['gameTableCount'] baseId = roomId * 10000 + 1 ftlog.info('DizhuCtrlRoomFriend._buildTableManager addTables', 'roomId=', self.roomId, 'shadowRoomId=', roomId, 'baseId=', baseId, 'tableCount=', count) for i in xrange(count): table = Table(DIZHU_GAMEID, roomId, baseId + i) tableManager.addTable(table) ftlog.info('FTRoom._buildTableManager Succ', 'roomId=', self.roomId, 'shadowRoomIds=', list(shadowRoomIds), 'seatCount=', seatCount, 'tableCount=', tableManager.allTableCount) return tableManager def _returnFee(self, userId, ftId, ftConf): if not ftConf.fee: return try: addCount, final = user_remote.addAsset(DIZHU_GAMEID, userId, ftConf.fee.assetKindId, ftConf.fee.count, 'FT_FEE', int(ftId)) ftlog.info('DizhuCtrlRoomFriend._returnFee', 'roomId=', self.roomId, 'userId=', userId, 'ftId=', ftId, 'nRound=', ftConf.nRound, 'playMode=', ftConf.playMode, 'canDouble=', ftConf.canDouble, 'fee=', ftConf.fee.toDict(), 'addCount=', addCount, 'final=', final) except: ftlog.error('DizhuCtrlRoomFriend._returnFee', 'roomId=', self.roomId, 'userId=', userId, 'ftId=', ftId, 'nRound=', ftConf.nRound, 'playMode=', ftConf.playMode, 'canDouble=', ftConf.canDouble, 'fee=', ftConf.fee.toDict()) def _collectFee(self, userId, ftId, ftConf): if ftConf.fee: consumeCount, final = user_remote.consumeAsset( DIZHU_GAMEID, userId, ftConf.fee.assetKindId, ftConf.fee.count, 'FT_FEE', int(ftId)) if consumeCount != ftConf.fee.count: raise TYBizException(-1, '房卡不足') ftlog.info('DizhuCtrlRoomFriend._collectFee', 'roomId=', self.roomId, 'userId=', userId, 'nRound=', ftConf.nRound, 'playMode=', ftConf.playMode, 'canDouble=', ftConf.canDouble, 'fee=', ftConf.fee.toDict(), 'cousumeCount=', ftConf.fee.count, 'final=', final) def _genFTId(self): from dizhu.friendtable import ft_service for _ in xrange(10): ftId = ft_service.genFTId() if not self.findFT(ftId): return ftId return None def _do_room__leave(self, msg): ftlog.info('DizhuCtrlRoomFriend._do_room__leave', 'roomId=', self.roomId, 'msg=', msg) userId = msg.getParam('userId') reason = msg.getParam('reason') clientRoomId = msg.getParam('clientRoomId') ft_table_remote.leaveRoom(self.gameId, userId, clientRoomId, reason)
def _invokeRpcMethod(markParams, argl, argd): ''' 进程内其它方法调用RPC方法的代理方法 ''' rpc = markParams['rpc'] rpcSrvType = markParams['rpcSrvType'] groupIndex = markParams['groupIndex'] future = markParams['future'] groupVal = 0 dstSid = None if rpcSrvType == RPC_FIRST_SERVERID: dstSid = argl[0] else: if groupIndex >= 0: groupVal = argl[groupIndex] if rpcSrvType == gdata.SRV_TYPE_UTIL: dstSid = _getRpcDstServerId(router._utilServer, groupVal) elif rpcSrvType == gdata.SRV_TYPE_ROOM: dstSid = getRpcDstRoomServerId(groupVal, 1) elif rpcSrvType == gdata.SRV_TYPE_TABLE: dstSid = getRpcDstRoomServerId(groupVal, 0) elif rpcSrvType == gdata.SRV_TYPE_CONN: dstSid = _getRpcDstServerId(router._connServer, groupVal) elif rpcSrvType == gdata.SRV_TYPE_HTTP: dstSid = _getRpcDstServerId(router._httpServer, groupVal) elif rpcSrvType == gdata.SRV_TYPE_ROBOT: dstSid = _getRpcDstServerId(router._robotServer, groupVal) elif rpcSrvType == gdata.SRV_TYPE_AGENT: dstSid = _getRpcDstServerId(router._agentServer, groupVal) elif rpcSrvType == gdata.SRV_TYPE_SDK_HTTP: dstSid = _getRpcDstServerId(router._sdkHttpServer, groupVal) elif rpcSrvType == gdata.SRV_TYPE_SDK_GATEWAY: dstSid = _getRpcDstServerId(router._gatewayHttpServer, groupVal) elif rpcSrvType == gdata.SRV_TYPE_CENTER: for dst, logics in gdata.centerServerLogics().items(): if groupVal in logics: dstSid = dst break if not dstSid: dstSid = router._centerServer.sids[0] if not dstSid: raise RpcException('RpcException ' + rpc + '! can not location the target server, rpcSrvType=' + str( rpcSrvType) + ' groupVal=' + str(groupVal)) rpcid = _getRpcId() if dstSid == gdata.serverId(): if markParams['syncCall']: if future: # TODO: Future RPC CALL 1 return _FutureResultLocal(markParams, argl, argd) else: ret = _invokeMethodLocked(markParams, argl, argd) return strutil.cloneData(ret) else: ftt = FTLoopTimer(0.01, 0, _invokeMethodLocked, markParams, argl, argd) ftt.start() return None mi = strutil.dumps({'cmd': _runenv._CMD_RPC_, 'rpc': rpc, 'argl': argl, 'argd': argd }) if markParams['syncCall']: if future: # TODO: Future RPC CALL 1 return _FutureResultRemote(rpc, dstSid, mi, rpcid, str(groupVal), _runenv._RPC_TIME_OUT) else: try: jstr = wrapper.query(dstSid, mi, rpcid, str(groupVal), _runenv._RPC_TIME_OUT) except FTMsgPackException, e: raise e except Exception, e: ftlog.warn('RpcException msg=', mi) raise RpcException('RpcException ' + rpc + ' ! query remote false, ' + str(e)) return _parseRpcResult(mi, jstr, rpc)
class HttpGetNdayAfterMatchs(object): '''N日后的比赛列表''' def __init__(self, interval, ndays, callback): self.httpContents = [] self.callback = callback self.now = datetime.datetime.now() self._afterday = (self.now + datetime.timedelta(days=ndays)).strftime('%Y-%m-%d') self.timer = FTLoopTimer(interval, -1, self._checkResult) self.timer.start() def __str__(self): return '%s:%s' % (self.now, self._afterday) def __repr__(self): return self.__str__() @property def key(self): return self.__str__() def _checkDate(self): return self.now.date() == datetime.datetime.now().date() def _checkResult(self): if ftlog.is_debug(): ftlog.debug('HttpGetNdayAfterMatchs', 'now=', self.now, '_afterday=', self._afterday) if not self._checkDate(): ftlog.info('hallsportlottery.HttpNdayAfterMatchList', '_checkDate=', self.now.date(), 'nowDate=', datetime.datetime.now().date()) if self.timer: self.timer.cancel() if self.callback: self.callback(self) return contents = http7Mgetschedulebydate(self._afterday) if contents and len(contents) > 0: if self.timer: self.timer.cancel() self.doContents(contents) if self.callback: self.callback(self) def doContents(self, contents): leagues = SportlotteryConf.leaguekeys() teams = SportlotteryConf.teamskeys() focusTeams = SportlotteryConf.focusTeamskeys() schedule = contents.get('Schedule') if schedule and len(schedule) > 0: for matchDict in schedule: match = matchDict['Id'] if match and len(match) >= 4: if match[1] not in leagues: continue if match[2] not in teams or match[3] not in teams: continue if match[2] not in focusTeams and match[ 3] not in focusTeams: continue d = { 'matchId': match[0], 'leagueId': match[1], 'homeTeamId': match[2], 'awayTeamId': match[3], 'timestamp': matchDict['Date'] / 1000 } self.httpContents.append(d)