def cb(ret):
for marryRow in ret.result:
marryId = long(marryRow[0])
marryTotalInfo = MarryTotalInfo(marryId)
marryTotalInfo.assginFromDB(marryRow)
#定时举行婚礼
if marryTotalInfo.flagWeding == MsgDef.WeddingFlagCmd.WEDDING_APPLYED:
leftSec = ffext.getTime() - marryTotalInfo.tmWedding
if leftSec <= 0 or marryTotalInfo.tmWedding == 0:
leftSec = 30
#ffext.dump('timer wedding', leftSec, marryTotalInfo)
def cb():
handleTimerWedding(marryId)
ffext.timer(leftSec*1000, cb)
#如果和谐离婚，定时离婚
if marryTotalInfo.tmEndWedding != 0 and marryTotalInfo.getInfoByGender(Base.Gender.MALE).status == MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING and \
marryTotalInfo.getInfoByGender(Base.Gender.FEMAIL).status == MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING:
leftSec = marryTotalInfo.tmEndWedding - ffext.getTime()
if leftSec <= 0:
leftSec = 10
def cbDiv():
handleTimerDivorce(marryId)
#ffext.timer(leftSec*1000, cbDiv)
#ffext.dump('marry divorcing left sec', leftSec, marryId)
#如果婚礼未举行
self.allMarryInfo[marryTotalInfo.marryId] = marryTotalInfo
#ffext.dump('load marryTotalInfo', marryTotalInfo)
#ffext.dump('load self.allMarryInfo', len(self.allMarryInfo))
return
def exe(self, owner, skill, objDest, param):
#TODO
from model import PlayerModel
newX = owner.x + 2
newY = owner.y + 2
if not owner.mapObj.canMove(newX, newY):
newX = owner.x
newY = owner.y
player = PlayerModel.Player()
player.forkFrom(owner, self.paramPropRate)
player.arenaCtrl.destPlayerRef = weakref.ref(objDest)
player.session = owner.session
owner.mapObj.playerEnterMap(player, newX, newY)
from model import ArenaModel
player.fsm.changeState(ffext.singleton(ArenaModel.ArenaStateAttack))
beginTm = ffext.getTime()
def cb():
if ffext.getTime() - beginTm >= 20 or player.isDeath():
player.mapObj.playerLeaveMap(player)
player.session = None
else:
try:
player.fsm.update(player, ffext.getTimeMs())
except:
pass
ffext.timer(1000, cb)
ffext.timer(1000, cb)
return
def initTimer(self):
nowSec = ffext.getTime()
secondUtilMiddleNight = SECONDS_PER_DAY - (nowSec % SECONDS_PER_DAY)
nowTm = ffext.datetime_now()
weekDay = nowTm.weekday()
if weekDay == 0:
weekDay = 7
nowCompVal = weekDay * 10000 + nowTm.hour * 100 + nowTm.minute
for wd, tmInfo in CITYWAR_START_TM_LIST.iteritems():
tmCompVal_1 = wd * 10000 + tmInfo[0]
tmCompVal_2 = wd * 10000 + tmInfo[1]
if nowCompVal >= tmCompVal_1:
# 目前配置时间点已经过了，算到本周日结束的时间
secondUtilWeekEnd = secondUtilMiddleNight + (
7 - weekDay) * SECONDS_PER_DAY
tm2 = secondUtilWeekEnd + (wd - 1) * SECONDS_PER_DAY + (
tmInfo[0] / 100) * 3600 + (tmInfo[0] % 100) * 60
ffext.timer(tm2 * 1000, onCityWarStart)
else:
# 目前配置时间还没来，还可以再打一场
tm1 = nowSec % SECONDS_PER_DAY
tm2 = (tmInfo[0] / 100) * 3600 + (tmInfo[0] % 100) * 60
ffext.timer((tm2 - tm1) * 1000, onCityWarStart)
pass
return True
def exe(self, owner, skill, objDest, param):
PuGong.exe(self, owner, skill, objDest, param)
def onTimer():
PuGong.exe(self, owner, skill, objDest, param)
ffext.timer(5 * 100, onTimer)
return
def update(self, monster, nowMs):
if monster.hp <= 0:
monster.lastAttackObjRef = None
if nowMs < monster.nextMoveTm + 10*1000:
return True
else:
if nowMs - monster.tmpInfo.get('_killedtm_', 0) <= 2000:#2秒内不要消失
return True
#先从地图上消失.,再出现
mapObj = monster.mapObj
oldMon = mapObj.monsterLeaveMap(monster)
#ffext.dump('monster leave map start reborn', monster.name)
def reborn():
oldMon.hp = oldMon.hpMax
oldMon.x = oldMon.bornX
oldMon.y = oldMon.bornY
mapObj.monsterEnterMap(oldMon, oldMon.x, oldMon.y)
if mapObj.copyMapHandler == None and oldMon.rebornSec > 0:
ffext.timer(1000*oldMon.rebornSec, reborn)
#ffext.dump('monster reborn', monster.name)
return True
if nowMs < monster.nextMoveTm:
if monster.lastAttackObjRef != None:
targetObj = monster.lastAttackObjRef()
if targetObj != None:#直接进入攻击模式
ffext.dump(monster.name, 'find target', targetObj.name)
monster.fsm.changeState(ffext.singleton(StateAttack))
return True
#回血
if monster.hp < monster.hpMax:
nowTm = ffext.getTime()
nAddHP = int((nowTm - monster.lastRecoverHPTM) * monster.hpMax / 100)
if nAddHP > 0:
monster.addHPMsg(nAddHP)
# 如果仇恨列表中有敌人在线，那么切换到战斗状态
if monster.aiFlag == 0:#被动攻击
if monster.lastAttackObjRef != None:
targetObj = monster.lastAttackObjRef()
if targetObj != None:#直接进入攻击模式
ffext.dump(monster.name, 'find target', targetObj.name)
monster.fsm.changeState(ffext.singleton(StateAttack))
return True
enemyObj = monster.selectEnemy()
if enemyObj:
monster.fsm.changeState(ffext.singleton(StateAttack))
return True
#先朝一个方向走，走到头，再随机选一个方向
curDir = monster.direction
if Base.distance(monster.x, monster.y, monster.bornX, monster.bornY) >= monster.calMaxReachEnemyDistance():
curDir = int((curDir + 4 ) % 8)
desrDir= Base.MOVE_HELP_DIRECTION[curDir]
curDir = desrDir[random.randint(0, len(desrDir) - 1)]
monster.direction = curDir
x, y = Base.getPosByDirection(monster.x, monster.y, curDir)
monster.nextMoveTm = nowMs + random.randint(5000, 10000)
monster.mapObj.moveMonster(monster, x, y)
return True
def cb():
if ffext.getTime() - beginTm >= 20 or player.isDeath():
player.mapObj.playerLeaveMap(player)
player.session = None
else:
try:
player.fsm.update(player, ffext.getTimeMs())
except:
pass
ffext.timer(1000, cb)
def cb():
leftTimes = objDest.tmpInfo.get('_leftSH_', 0)
if leftTimes <= 0 or objDest.isDeath():
return
hurtResult = calRealMagicHurt(owner, objDest, skill, selfvar, True,
True, IGNORE_MAGIC_DEFEND)
objDest.subHurtResult(owner, hurtResult)
leftTimes = leftTimes - 1
objDest.tmpInfo['_leftSH_'] = leftTimes
ffext.timer(cbinterval * 1000, cbvar)
return
def cb():
leftTimes = objDest.tmpInfo.get('_leftZYS_', 0)
leftTimes = leftTimes - 1
objDest.tmpInfo['_leftZYS_'] = leftTimes
if leftTimes <= 0:
return
objDest.addHPMsg(self.paramHurt)
ffext.timer(3 * 1000, cbvar)
buff = objDest.buffCtrl.getBuff(MsgDef.BuffType.ZHIYUSHU)
if not buff:
objDest.buffCtrl.addBuff(MsgDef.BuffType.ZHIYUSHU, 3, 0, 320)
objDest.updateBuffMsg()
return
def closeCopyMap(self, mapname, kickpoutMap=None, x=None, y=None):
def doOps():
mapObj = self.allMap.pop(mapname, None)
if None == mapObj:
return None
self.allCopyMap.pop(mapname, None)
#如果地图上有人，那么踢人
self.kickoutTo(mapObj, kickpoutMap, x, y)
#如果有怪，那么把怪给释放掉, 这个时候已经没有人了，不用广播消息了,直接把怪物释放掉即可
mapObj.cleanup()
ffext.dump('closeCopyMap', mapname)
ffext.timer(1, doOps) #立即释放掉
return True
def cb():
player1 = ref1()
player2 = ref2()
if player1 and player1.mapObj != None:
if not player2 or player2.mapObj == None:#player1 win
winQieCuo(player1)
return
if player2.ctrlQieCuo.startMap != player2.mapname:
winQieCuo(player1)
return
dist = Base.distance(player2.x, player2.y, player2.ctrlQieCuo.startX, player2.ctrlQieCuo.startY)
if dist > Base.QIECUO_MAX_RANGE:
if player2.ctrlQieCuo.warnTimes == 0:
player2.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '警告!切磋出界3秒后将会被判输!'))
player2.ctrlQieCuo.warnTimes += 1
if player2.ctrlQieCuo.warnTimes == 4:
winQieCuo(player1)
return
else:
player2.ctrlQieCuo.warnTimes = 0
if player2.hp == 1:
winQieCuo(player1)
return
if player1.ctrlQieCuo.startMap != player1.mapname:
winQieCuo(player2)
return
dist = Base.distance(player1.x, player1.y, player1.ctrlQieCuo.startX, player1.ctrlQieCuo.startY)
if dist > Base.QIECUO_MAX_RANGE:
if player1.ctrlQieCuo.warnTimes == 0:
player1.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '警告!出界3秒后将会被判输!'))
player1.ctrlQieCuo.warnTimes += 1
if player1.ctrlQieCuo.warnTimes == 4:
winQieCuo(player2)
return
else:
player1.ctrlQieCuo.warnTimes = 0
if player1.hp == 1:
winQieCuo(player2)
return
ffext.dump('check win ...')
ffext.timer(1000, cb)
else:
if player2:
winQieCuo(player2)
return
return
def exe(self, owner, skill, objDest, param):
self.paramHurt = self.paramNomal
PuGong.exe(self, owner, skill, objDest, param)
objDestRef = weakref.ref(objDest)
ownerRef = weakref.ref(owner)
def cb():
objDest = objDestRef()
owner = ownerRef()
if not objDest or not owner:
return
self.paramHurt = self.paramHurtRate
PuGong.exe(self, owner, skill, objDest, param)
objDest.showEffect(MsgDef.EffectType.EFFECT_ZHUO_SHAO)
for k in range(0, self.times):
ffext.timer(int(self.paramSec * k * 1000 / self.times), cb)
return
def checkOnInit(self):
nowTime = ffext.getTime()
nowTm = ffext.datetime_now()
if self.last_refresh_time > 0:
if ffext.tmIsSameDay(self.last_refresh_time, nowTime):
#服务器重启时，跨越了凌晨
self.onMiddleNightEvent()
# 是否跨周
if nowTm.weekday() == 0:
self.onWeeklyNightEvent()
pass
# 计算出到达午夜的时间，启动定时器
secondUtilMiddleNight = SECONDS_PER_DAY - (nowTime % SECONDS_PER_DAY)
ffext.timer(secondUtilMiddleNight * 1000, self.onMiddleNightEvent)
# 计算到达下一个周（一）午夜的时间，启动定时器
secondUtilNextWeek = secondUtilMiddleNight + (
6 - nowTm.weekday()) * SECONDS_PER_DAY
ffext.timer(secondUtilNextWeek * 1000, self.onWeeklyNightEvent)
return
def handleReborn(self, rebornTm=Base.REBORN_TIMEOUT, rebornLife=10):
#血回复10% 死亡后2s后，自动回到重生点
if self.fsm: #模拟怪的player，不需要重生
return
playerref = weakref.ref(self)
def cb():
player = playerref()
if not player:
return
if not player.isDeath():
return
player.hp = int(player.hpMax * 10 / 100)
x = player.x
y = player.y
mapObj = player.mapObj
if mapObj.cfg.reviveMap != None:
mapName = mapObj.cfg.reviveMap.mapname
x = mapObj.cfg.reviveMap.x
y = mapObj.cfg.reviveMap.y
mapObj = MapMgr.getMapMgr().allocMap(mapName)
#ffext.info('reborn name=%s, offlineMap=%s, x=%d, y=%d' % (player.name, player.mapname, x, y))
#发送重生消息
retMsg = buildPlayerInfoRet(player)
retMsg.mapname = mapObj.mapname
retMsg.x = x
retMsg.y = y
player.sendMsg(MsgDef.ServerCmd.REBORN, MsgDef.RebornRet(retMsg))
mapObj.playerEnterMap(player, x, y, False)
#ffext.info('reborn2 name=%s, offlineMap=%s, x=%d, y=%d' % (player.name, player.mapname, x, y))
# 角色重生也要出发到副本
if mapObj.copyMapHandler:
try:
mapObj.copyMapHandler.handlePlayerRevive(mapObj, player)
except:
ffext.error(
'mapObj.copyMapHandler.handlePlayerRevive failed mapname=%s player=%s'
% (mapObj.mapname, player.name))
return
ffext.timer(rebornTm, cb)
return
def funcToClose(sessOther):
if sessOther.user.accountid == accountId:
ffext.warn('check relogin accountId=%d, name=%s' %
(accountId, sessOther.user.username))
#if reconnectUid:
# session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.LOGIN, Base.lang('账号在其他地方登录')))
#else:
# sessOther.close()
# 登出-记录log
LogModel.logLoginData(accountId, 0, '',
LogModel.LoginOpType.LOGOUT,
LogModel.LoginReason.KICKOUT)
sessOther.sendMsg(MsgDef.ServerCmd.RELOGIN,
MsgDef.ReLoginRet())
def cbClose():
sessOther.close()
ffext.timer(500, cbClose)
return True
def addBuff(self, buffId, buffSec=0, buffEffect=0, fromSkillId=0):
curBuff = self.allBuff.get(buffId)
if curBuff:
return False
endTime = 0
if buffSec > 0:
endTime = ffext.getTime() + buffSec
owner = self.ownerref
def cb():
player = owner()
if not player or player.mapObj == None:
return
player.buffCtrl.delBuff(buffId)
player.updateBuffMsg()
ffext.timer(buffSec * 1000, cb)
newBuff = MsgDef.BuffStatus(endTime, {1: buffEffect}, fromSkillId)
self.allBuff[buffId] = newBuff
player = self.ownerref()
return
def handleObjDie(self, mapObj, obj):
playerOther = None
bWin = True
if self.autoPlayerRef != None:
playerOther = self.autoPlayerRef()
def cb():
playerOther.mapObj.playerLeaveMap(playerOther)
if playerOther:
ffext.timer(100, cb)
if obj.uid != playerOther.uid:
bWin = False
self.autoPlayerRef =None
#self.onEnd()
for k, v in mapObj.allPlayer.iteritems():
if v.uid != playerOther.uid:
v.sendMsg(MsgDef.ServerCmd.COPYMAP_END, MsgDef.CopymapEndRet(1, AWARD_EXP, GOLD_ADD, []))
v.AddScoreArena(getScoreBytimes(v.arenaCtrl.usedTimes))
#v.taskCtrl.trigger(Base.Action.COPY_MAP, int(mapObj.mapname), 1)
#5秒后关闭副本
self.createTime = ffext.getTime() + 5 - LIMIT_SEC
return True
def exe(self, owner, skill, objDest, param):
objDest.tmpInfo['_leftSH_'] = int(self.paramTotalSec /
self.paramInterval)
def cb():
leftTimes = objDest.tmpInfo.get('_leftSH_', 0)
if leftTimes <= 0 or objDest.isDeath():
return
hurtResult = calRealMagicHurt(owner, objDest, skill, selfvar, True,
True, IGNORE_MAGIC_DEFEND)
objDest.subHurtResult(owner, hurtResult)
leftTimes = leftTimes - 1
objDest.tmpInfo['_leftSH_'] = leftTimes
ffext.timer(cbinterval * 1000, cbvar)
return
cbvar = cb
selfvar = self
cbinterval = self.paramInterval
ffext.timer(self.paramInterval * 1000, cb)
return
def init(self):
def cb(ret):
self.allRank = []
i = 0
for row in ret.result:
i += 1
#sql = "select uid,name,job,gender,level,fightpower,arenascore from player where arenascore > 0 order by arenascore desc limit 1000 "
tmpMsg = MsgDef.ArenaPlayerData(long(row[0]), row[1],
int(row[2]), int(row[3]),
int(row[4]), int(row[5]), i,
int(row[6]))
self.allRank.append(tmpMsg)
return
DbService.getPlayerService().loadArenaRankInfo(0, 1000, cb)
def cbTimer():
#print('load arena data')
DbService.getPlayerService().loadArenaRankInfo(0, 1000, cb)
ffext.timer(10 * 1000, cbTimer)
ffext.timer(10 * 1000, cbTimer)
return True
def cb(dbSet):
db = dbSet['player']
dbitem = dbSet['item']
dbPet = dbSet['pet']
session = ffext.SessionNone()
player = PlayerModel.Player(db.result[0])
session.setPlayer(player)
player.session = session
if dbitem.isOk():
player.itemCtrl.fromData(dbitem.result)
player.petCtrl.fromData(dbPet.result)
player.direction = Base.Direction.RIGHT
player.arenaCtrl.destPlayerRef = weakref.ref(playerSrc)
#状态机
player.fsm = MonsterAI.FSM(player)
def goTo():
mapObj.copyMapHandler.autoPlayerRef = weakref.ref(player)
mapObj.playerEnterMap(player, 69, 72)
player.fsm.changeState(ffext.singleton(ArenaStateAttack))
ffext.timer(1000, goTo)
return
def exe(self, owner, skill, objDest, param):
if objDest.getType() != Base.PLAYER:
return
objDest.tmpInfo['_leftZYS_'] = 10
def cb():
leftTimes = objDest.tmpInfo.get('_leftZYS_', 0)
leftTimes = leftTimes - 1
objDest.tmpInfo['_leftZYS_'] = leftTimes
if leftTimes <= 0:
return
objDest.addHPMsg(self.paramHurt)
ffext.timer(3 * 1000, cbvar)
buff = objDest.buffCtrl.getBuff(MsgDef.BuffType.ZHIYUSHU)
if not buff:
objDest.buffCtrl.addBuff(MsgDef.BuffType.ZHIYUSHU, 3, 0, 320)
objDest.updateBuffMsg()
return
cbvar = cb
ffext.timer(3 * 1000, cb)
return
def processXibaiReq(session, msg = None):
player = session.player
if msg.opstype == 0:
if player.pkSinValue >= 100 and player.pkSinValue < 300:#橙：(100<=罪恶值<300)时显示，被人杀死后3%掉落身上任一装备。
pass
else:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '只有橙色罪恶值才能洗白'))
return
gold = 500
if player.gold < gold:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '金币不足:%d'%(gold)))
return
player.addGold(gold, True)
retMsg = MsgDef.XibaiRet(msg.opstype)
session.sendMsg(MsgDef.ServerCmd.XIBAI_OPS, retMsg)
def cb():
player.pkSinValue = 0
#更新pk罪恶值
session.broadcast(MsgDef.ServerCmd.PK_SIN_UPDATE_OPS, MsgDef.PkSinUpdateRet(0, player.pkSinValue, player.uid))
return
ffext.timer(1000*10, cb)
return
return
def addWarVsInfo(self, guild1, guild2):
warInfo = GuildWarVSInfo()
warId = idtool.allocTmpId()
warInfo.warId = warId
warInfo.guild1 = guild1
warInfo.guild2 = guild2
warInfo.tmWarStart = ffext.getTime() + WAR_SEC_START
self.allGuildWarVSInfo[warInfo.warId] = warInfo
def cbStart():
retMsg = MsgDef.GuildWarOpsRet(MsgDef.GuildWarOpsCmd.WAR_START,
warInfo.tmWarStart)
retMsg.warApplyGuild = buildGuildInfoMsg(guild1)
retMsg.warFightGuild = buildGuildInfoMsg(guild2)
guild1.sendMsg2OnlineMember(MsgDef.ServerCmd.GUILD_WAR_OPS, retMsg)
guild2.sendMsg2OnlineMember(MsgDef.ServerCmd.GUILD_WAR_OPS, retMsg)
# 更新颜色
def updatePlayerColor1(player):
player.nameColor = MsgDef.ECOLOR.BLUE
player.SendChangeApprMsg()
return
def updatePlayerColor2(player):
player.nameColor = MsgDef.ECOLOR.YELLOW
player.SendChangeApprMsg()
return
guild1.foreachOnlineMember(updatePlayerColor1)
guild2.foreachOnlineMember(updatePlayerColor2)
return
def cbEnd():
warInfo = self.allGuildWarVSInfo.pop(warId, None)
if not warInfo:
return
warInfo.tmWarStart = 0
retMsg = MsgDef.GuildWarOpsRet(MsgDef.GuildWarOpsCmd.WAR_END,
warInfo.tmWarStart)
retMsg.winGuildId = 0
if warInfo.guildScore1 >= warInfo.guildScore2:
retMsg.winGuildId = warInfo.guild1.guildID
else:
retMsg.winGuildId = warInfo.guild2.guildID
retMsg.warApplyGuild = buildGuildInfoMsg(guild1)
retMsg.warFightGuild = buildGuildInfoMsg(guild2)
guild1.sendMsg2OnlineMember(MsgDef.ServerCmd.GUILD_WAR_OPS, retMsg)
guild2.sendMsg2OnlineMember(MsgDef.ServerCmd.GUILD_WAR_OPS, retMsg)
# 更新颜色
def updatePlayerColor(player):
player.nameColor = 0
player.SendChangeApprMsg()
return
guild1.foreachOnlineMember(updatePlayerColor)
guild2.foreachOnlineMember(updatePlayerColor)
return
ffext.timer(WAR_SEC_START * 1000, cbStart)
ffext.timer((WAR_SEC_START + WAR_SEC_END) * 1000, cbEnd)
return warInfo
def chekcCopyMap():
ffext.timer(Base.COPY_MAP_TIMER_MS, chekcCopyMap)
getMapMgr().chekcCopyMap()
def initTimer(self):
ffext.timer(Base.COPY_MAP_TIMER_MS, chekcCopyMap)
def autoRecoverHpMp():
#ffext.dump('autoRecoverHpMp...')
ffext.getSessionMgr().foreach(recoverHpMp)
ffext.timer(Base.PLAYER_RECOVER_HPMP_MS, autoRecoverHpMp)
return
def cbTimer():
#print('load arena data')
DbService.getPlayerService().loadArenaRankInfo(0, 1000, cb)
ffext.timer(10 * 1000, cbTimer)
def handleDrop(self, objAttackKill):
if objAttackKill.getType() != Base.PLAYER:
return
objAttack = objAttackKill
#击杀血量最多的人，给装备奖励
maxObj = objAttackKill
maxHurt = 0
for uid, data in self.allHurtCount.iteritems():
player = self.mapObj.getPlayerById(uid)
if not player:
continue
if data.hurt > maxHurt:
maxObj = player
maxHurt = data.hurt
maxTeam = None
maxTeamHurt = 0
for uid, data in self.allTeamHurtCount.iteritems():
from model import TeamModel
team = TeamModel.getTeamMgr().getTeamById(uid)
if not team:
continue
if data.hurt > maxTeamHurt:
maxTeam = team
maxTeamHurt = data.hurt
#初始化数据，方便复活
self.allHurtCount = {}
self.allTeamHurtCount = {}
objAttack.addExp(self.propCfg.expval, True)
burstItemList = []
from handler import ItemHandler
def burstItemCallBack(itemCfgId, num):
burstItemList.append((itemCfgId, num))
def giveItemById(obj, retMsg, itemCfgId, num):
if itemCfgId == 0: # 金币
obj.addGold(num, True)
return
item = obj.itemCtrl.addItemByCfgId(itemCfgId, num)
if item:
ffext.dump('whenDie itemEnterMap', item.itemCfg.name, num)
# self.mapObj.itemEnterMap(item, self.x + 1, self.y + 1)
if item.__class__ == list:
for k in item:
retItem = MsgDef.Item()
ItemHandler.buildItem(retItem, k)
retMsg.items.append(retItem)
else:
retItem = MsgDef.Item()
ItemHandler.buildItem(retItem, item)
retMsg.items.append(retItem)
return
def burstItemCallBackName(name, num):
from model import ItemModel
itemCfg = ItemModel.getItemMgr().getCfgByName(name)
if itemCfg:
burstItemCallBack(itemCfg.cfgId, num)
else:
ffext.error('burstItemCallBackName %s %d' % (name, num))
return
for k in self.propCfg.allBurstCfg:
k.genBurst(burstItemCallBackName)
burstBagCfg = getMonsterMgr().cfgLevel2Drop.get(self.propCfg.level)
if burstBagCfg:
ffext.dump('burstBagCfg', burstBagCfg)
# 1 根据表【怪物掉落包个数】获得该等级怪物的掉落物品的个数
# 2 每个包掉落概率：根据怪物的等级和类型，获得是否该包是否掉落
# 3 金币数目：怪物实际掉落金币=怪物等级金币*怪物的金币倍数
# 4 物品：每一个掉落包从【金币/物品1/物品2/物品3/物品4】中随机一个
# 5 若随机到【/物品1/物品2/物品3/物品4】，寻找制定的掉落包ID内物品
monType = self.propCfg.getMonDifficultyType()
num = burstBagCfg.numList[monType]
rate = burstBagCfg.rateList[monType]
dropBagList = burstBagCfg.bagIdList
for k in range(num):
rand = random.randint(1, 100)
ffext.dump('rate trace', rate, rand, len(dropBagList))
if rate >= rand and len(dropBagList) > 0: # 爆落
destBagId = dropBagList[rand % len(dropBagList)]
ffext.dump('rate trace', rate, rand, len(dropBagList),
destBagId)
if destBagId == 0: # 金币
gold = random.randint(burstBagCfg.goldMin,
burstBagCfg.goldMax)
burstItemCallBack(
destBagId,
gold * self.propCfg.expgoldtimes) # *怪物的金币倍数
continue
destBagCfg = getMonsterMgr().bagid2cfg.get(destBagId)
if destBagCfg:
for itemCfgId in destBagCfg.itemIdList:
burstItemCallBack(itemCfgId, 1)
ffext.dump('handledrop', burstItemList, objAttack.name, maxHurt,
maxTeamHurt)
if maxHurt >= maxTeamHurt: #个人获得道具
objAttack = maxObj
retMsg = MsgDef.MonserBurstItemsRet(self.uid, objAttack.uid, [],
self.propCfg.expval, 0)
for k in burstItemList:
giveItemById(objAttack, retMsg, k[0], k[1])
if len(retMsg.items) > 0:
ItemHandler.processQueryPkg(objAttack.session)
objAttack.sendMsg(MsgDef.ServerCmd.MONSTER_BURST_ITEMS, retMsg)
return
else: #团队获得道具
allPlayers = []
for k, v in maxTeam.getTeamMember().iteritems():
p = self.mapObj.getPlayerById(k)
if p:
allPlayers.append(p)
if not allPlayers:
return
objPrize = allPlayers[random.randint(0, len(allPlayers) - 1)]
retMsg = MsgDef.MonserBurstItemsRet(self.uid, objPrize.uid, [], 0,
0)
objPrizeRef = weakref.ref(objPrize)
def tmpPrizeCallBack():
objPrize = objPrizeRef()
if not objPrize:
return
for k in burstItemList:
giveItemById(objPrize, retMsg, k[0], k[1])
if len(retMsg.items) > 0:
ItemHandler.processQueryPkg(objPrize.session)
retMsg.teamBurstInfo = []
callbackArg = {'players': {}, 'prizecallback': tmpPrizeCallBack}
for arg in allPlayers:
randNum = 1
if arg == objPrize:
randNum = 6
else:
randNum = random.randint(1, 5)
retMsg.teamBurstInfo.append(
MsgDef.BurstRandInfo(arg.uid, arg.name, randNum))
callbackArg[arg.uid] = arg.name
for k in burstItemList:
ffext.dump('busrt info', k)
from model import ItemModel
itemCfg = ItemModel.getItemMgr().getCfgByCfgId(k[0])
if itemCfg:
retItem = MsgDef.Item()
ItemModel.tmpBuildItem(retItem, itemCfg)
retMsg.items.append(retItem)
def timercb():
ffext.dump("timercb teamburst...")
cb = callbackArg['prizecallback']
if cb:
callbackArg['prizecallback'] = None
cb()
return
ffext.timer(5 * 1000, timercb)
ffext.dump('monter burst items', retMsg)
for objAttack in allPlayers:
retMsg.callbackId = objPrize.addCallBack(
burstCallBack, callbackArg)
objAttack.sendMsg(MsgDef.ServerCmd.MONSTER_BURST_ITEMS, retMsg)
return
def onTimer():
gMonsterMgr.onTimer()
ffext.timer(Base.MONSTER_TIMER_MS, onTimer)
def processMarryOPS(session, msg):
#ffext.dump('processMarryOPS', msg)
opstype = msg.opstype
cmd = MsgDef.ClientCmd.MARRIAGE_OPS
player = session.player
if opstype == MsgDef.MarriageClientCmd.MARRY_QUERY_STATUS: #查询结婚状态
retMsg = processMarryOpsMsgRet(opstype, player,
player.marriageCtrl.marryFlag, 0, '', 0)
#print(retMsg)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, retMsg)
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_APPLY_TASK:
marryTotalInfo = player.marriageCtrl.marryTotalInfo
nextTaskId = MARRY_TASK_ID
# if marryTotalInfo:#直接接任务
# if session.player.marriageCtrl.getStatus() != MsgDef.MarryStatusCmd.MARRY_STATUS_NOT:
# session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, processErrorMsgRet(opstype, cmd, '不能领取任务！'))
# return
# session.player.marriageCtrl.setStatus(MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO)
#
# for taskid, task in session.player.taskCtrl.allTask.iteritems():
# session.player.taskCtrl.delTaskById(taskid)
# newTask = session.player.taskCtrl.addTaskById(nextTaskId, False)
# if newTask:
# DbService.getPlayerService().replaceTask(session.player, newTask, taskid)
# break
# from handler import TaskHandler
# TaskHandler.processQueryTask(session)
# session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, processMarryOpsMsgRet(opstype, session.player, MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO))
# DbService.getPlayerService().updateMarry(marryTotalInfo)
# return
team = TeamModel.getTeamMgr().getTeamById(
session.player.teamCtrl.teamID)
if not team:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '请先组队！'))
return
if len(team.getTeamMember()) != 2:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '请先组队2人！'))
return
if player.isMarry():
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '你已经结婚！'))
return
destPlayer = None
mateSession = None
marryTotalInfo = None
for key, valdata in team.getTeamMember().iteritems():
mateSession = ffext.getSessionMgr().findByUid(valdata.uid)
if not mateSession:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd,
'队伍异常:%d' % (valdata.uid)))
continue
val = mateSession.player
if val.uid != session.player.uid:
if val.gender == player.gender:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '性别不符！'))
return
mateUid = val.uid
destPlayer = val
if destPlayer.isMarry():
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '对方已经结婚！'))
return
husbend = player
wife = val
if player.gender == Base.Gender.FEMAIL:
husbend = val
wife = player
strFlag = player.tmpInfo.get('_marry_task_apply_')
marryTotalInfo = None
if strFlag == None:
flag2 = destPlayer.tmpInfo.get('_marry_task_apply_')
if flag2 != None:
marryTotalInfo = flag2
else:
marryTotalInfo = MarryModel.getMarryMgr(
).allocMarryTotalInfo(husbend, wife)
player.tmpInfo['_marry_task_apply_'] = marryTotalInfo
session.player.marriageCtrl.setStatus(
MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO)
if destPlayer.tmpInfo.get('_marry_task_apply_') == None:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '等待对方确认！'))
husbend.sendMsg(
MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO, 0, '',
0, 0, marryTotalInfo))
wife.sendMsg(
MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO, 0, '',
0, 0, marryTotalInfo))
return
# marryTotalInfo = MarryModel.allockMarryInfo()
#wife.marriageCtrl.setStatus(MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO)
ffext.dump('dump marry', marryTotalInfo)
break
#领取结婚任务 | 未婚-结婚进行中任务
nextTaskId = MARRY_TASK_ID
for taskid, task in session.player.taskCtrl.allTask.iteritems():
session.player.taskCtrl.delTaskById(taskid)
newTask = session.player.taskCtrl.addTaskById(nextTaskId, False)
if newTask:
DbService.getPlayerService().replaceTask(
session.player, newTask, taskid)
break
for taskid, task in destPlayer.taskCtrl.allTask.iteritems():
destPlayer.taskCtrl.delTaskById(taskid)
newTask = destPlayer.taskCtrl.addTaskById(nextTaskId, False)
if newTask:
DbService.getPlayerService().replaceTask(
destPlayer, newTask, taskid)
break
from handler import TaskHandler
TaskHandler.processQueryTask(session)
TaskHandler.processQueryTask(destPlayer.session)
session.sendMsg(
MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
processMarryOpsMsgRet(opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO))
destPlayer.sendMsg(
MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
processMarryOpsMsgRet(opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO))
DbService.getPlayerService().addMarry(player,
player.marriageCtrl.marryId,
mateSession.player.uid,
ffext.getTime())
DbService.getPlayerService().updateMarry(marryTotalInfo)
player.tmpInfo['_marry_task_apply_'] = None
destPlayer.tmpInfo['_marry_task_apply_'] = None
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_GIVEUP_TASK: #13:放弃结婚任务
if not player.marriageCtrl:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, 'CTRL错误！'))
return
marryTotalInfo = player.marriageCtrl.marryTotalInfo
if not marryTotalInfo or marryTotalInfo.coupleData[
0].status != MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_GO:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '未领取任务！'))
return
anotherInfo = marryTotalInfo.getInfoByAnotherGender(player.gender)
destPlayer = player.mapObj.getPlayerById(anotherInfo.uid)
mateSession = None
if destPlayer:
mateSession = destPlayer.session
marryTotalInfo.getInfoByGender(
player.gender).status = MsgDef.MarryStatusCmd.MARRY_STATUS_NOT
marryTotalInfo.getInfoByAnotherGender(
player.gender).status = MsgDef.MarryStatusCmd.MARRY_STATUS_NOT
MarryModel.getMarryMgr().delMarryById(marryTotalInfo.marryId)
DbService.getPlayerService().updateMarryDivorce(marryTotalInfo.marryId)
DbService.getPlayerService().updateMarryDivorcePlayer(player.uid)
DbService.getPlayerService().updateMarryDivorcePlayer(anotherInfo.uid)
# 提交任务 | 结婚进行中任务 - 已婚
task = session.player.taskCtrl.getTask(MARRY_TASK_ID)
if task:
from model import TaskModel
task.status = TaskModel.TaskStatus.FINISH
session.player.taskCtrl.checkNewTask(task)
from handler import TaskHandler
TaskHandler.processQueryTask(session)
ffext.dump('dump marry', marryTotalInfo)
player.marriageCtrl.divorceForce()
player.tmpInfo['_marry_task_apply_'] = None
# 发送回包
ret_msg = processMarryOpsMsgRet(opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_NOT)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
if destPlayer:
task2 = destPlayer.taskCtrl.getTask(MARRY_TASK_ID)
if task2:
from model import TaskModel
task2.status = TaskModel.TaskStatus.FINISH
destPlayer.taskCtrl.checkNewTask(task2)
from handler import TaskHandler
TaskHandler.processQueryTask(mateSession)
destPlayer.marriageCtrl.divorceForce()
# 发送回包
ret_msg = processMarryOpsMsgRet(
opstype, destPlayer, MsgDef.MarryStatusCmd.MARRY_STATUS_NOT)
mateSession.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
destPlayer.tmpInfo['_marry_task_apply_'] = None
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_COMMIT_TASK:
if not player.marriageCtrl:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, 'CTRL错误！'))
return
marryTotalInfo = player.marriageCtrl.marryTotalInfo
if not marryTotalInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '未领取任务！'))
return
anotherInfo = marryTotalInfo.getInfoByAnotherGender(player.gender)
destPlayer = player.mapObj.getPlayerById(anotherInfo.uid)
#ffext.dump('MARRRRRRRRRRRRR!')
task = player.taskCtrl.getTask(MARRY_TASK_ID)
ffext.dump('MARRYTASK', task)
if task:
from model import TaskModel
task.status = TaskModel.TaskStatus.FINISH
player.taskCtrl.checkNewTask(task)
from handler import TaskHandler
TaskHandler.processQueryTask(session)
ffext.dump('dump marry', marryTotalInfo)
marryTotalInfo.getInfoByGender(
player.gender
).status = MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_FINISH
mateSession = None
if destPlayer:
mateSession = destPlayer.session
status1 = marryTotalInfo.getInfoByGender(player.gender).status
status2 = marryTotalInfo.getInfoByAnotherGender(player.gender).status
#ffext.dump('STATUS1',status1)
#ffext.dump('STATUS2',status2)
#ffext.dump('MARRRRRRRRRRRRR!')
if status1 == MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_FINISH and status1 == status2:
marryTotalInfo.getInfoByGender(
player.gender
).status = MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED
marryTotalInfo.getInfoByAnotherGender(
player.gender
).status = MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED
DbService.getPlayerService().updateMarry(marryTotalInfo)
session.sendMsg(
MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
processMarryOpsMsgRet(
opstype, destPlayer,
MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_FINISH))
destPlayer.sendMsg(
MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
processMarryOpsMsgRet(
opstype, destPlayer,
MsgDef.MarryStatusCmd.MARRY_STATUS_TASK_FINISH))
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_SEND:
# 发请帖
friends = session.player.friendCtrl.getFriend()
friends_lst = []
for k, v in friends.iteritems():
friends_lst.append(v.name)
#ffext.dump('Friends_lst', friends_lst)
msg.visitors = friends_lst
ffext.dump('QINGTIEMSG', msg)
if msg.visitors == None:
return
if len(msg.visitors) > WEDDING_SEND_MAX_PLAYER:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '邀请人数太多了！'))
return
if len(msg.msg) > WEDDING_SEND_MAX_STR:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '请帖文字太长了！'))
return
marryTotalInfo = session.player.marriageCtrl.marryTotalInfo
marryTotalInfo.flagXiTie += 1
hasSend = []
for k in msg.visitors:
if k in hasSend:
continue
hasSend.append(k)
#查找所有的被邀请者的“姓名”
otherSession = ffext.getSessionMgr().getSessionByName(k)
if otherSession:
toPlayer = otherSession.player
msg = msg.msg + '\n\n\n\n' + '系统提醒:请去结婚界面确认是否参加婚礼!'
title = None
#ffext.dump('喜帖!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
session.player.mailCtrl.sendMail(toPlayer.uid, 0, title, msg)
otherSession.sendMsg(
MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED, 0,
msg.msg))
#状态变化，更新数据库
DbService.getPlayerService().updateMarry(marryTotalInfo)
session.sendMsg(
MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
processMarryOpsMsgRet(opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED,
0, msg.msg))
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_APPLY_WEDDING: #申请结婚
marryTotalInfo = player.marriageCtrl.marryTotalInfo
if not marryTotalInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '先完成結婚任務！'))
return
if marryTotalInfo.flagWeding != MsgDef.WeddingFlagCmd.WEDDING_NOT_APPLY and marryTotalInfo.flagWeding != MsgDef.WeddingFlagCmd.WEDDING_FAIL:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '已经申请过！'))
return
mate = marryTotalInfo.getInfoByAnotherGender(player.gender)
otherPlayer = player.mapObj.getPlayerById(mate.uid)
if not otherPlayer:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '配有没有在线！'))
return
strFlag = player.tmpInfo.get('_wedding_apply_')
if strFlag == None:
player.tmpInfo['_wedding_apply_'] = True
strFlag2 = otherPlayer.tmpInfo.get('_wedding_apply_')
if strFlag2 == None:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '等待配偶确认！'))
ret_msg = processMarryOpsMsgRet(opstype, player)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
ret_msg = processMarryOpsMsgRet(opstype, otherPlayer)
otherPlayer.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
return
player.tmpInfo['_wedding_apply_'] = None
otherPlayer.tmpInfo['_wedding_apply_'] = None
marryTotalInfo.flagWeding = MsgDef.WeddingFlagCmd.WEDDING_APPLYED
leftSec = WEDDING_INTERVAL
marryTotalInfo.tmWedding = ffext.getTime() + leftSec #1 分钟后开始
marryId = marryTotalInfo.marryId
def cb():
MarryModel.handleTimerWedding(marryId)
ffext.timer(leftSec * 1000, cb)
ret_msg = processMarryOpsMsgRet(opstype, player)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
#状态变化，更新数据库
DbService.getPlayerService().updateMarry(marryTotalInfo)
if mate:
marryPlayer = ffext.getSessionMgr().findByUid(mate.uid)
if marryPlayer:
marryPlayer.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_QUERY_ALL_MARRIAGE: ##12:查询所有夫妻，方便参加婚礼
allMarriage = MarryModel.getAllMarriage()
ret_msg = processMarryOpsMsgRet(opstype, None)
ret_msg.allMarriageInfo = []
num = 0
for k, marryTotalInfo in allMarriage.iteritems():
num += 1
if num >= 100:
break
if marryTotalInfo.flagWeding != MsgDef.WeddingFlagCmd.WEDDING_APPLYED:
continue
baseInfo = MsgDef.MarriageBaseInfo(marryTotalInfo.marryId, [], [])
for k in marryTotalInfo.coupleData:
num += 1
if num >= 100:
break
tmpmsg = MsgDef.MarriagePlayerMsg()
tmpmsg.uid = k.uid
tmpmsg.name = k.name
tmpmsg.job = k.job
tmpmsg.gender = k.gender
tmpmsg.level = k.level
tmpmsg.status = k.status
baseInfo.coupleData.append(tmpmsg)
for k in marryTotalInfo.listAttends:
num += 1
if num >= 100:
break
tmpmsg = MsgDef.MarriagePlayerMsg()
tmpmsg.uid = k.uid
tmpmsg.name = k.name
tmpmsg.job = k.job
tmpmsg.gender = k.gender
tmpmsg.level = k.level
tmpmsg.status = k.status
baseInfo.listAttends.append(tmpmsg)
ret_msg.allMarriageInfo.append(baseInfo)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
elif opstype == MsgDef.MarriageClientCmd.MARRY_ATTEND_WEEDING:
# 参加婚礼，扣礼金，发道具
marryTotalInfo = MarryModel.getMarryMgr().getMarryTotalInfo(
msg.marryId)
#marryPlayer = ffext.getSessionMgr().findByUid(msg.marryUid)
if not marryTotalInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, "对方还未结婚!"))
return
gold = 500
item1 = 1040188
item2 = 1040189
if player.gold < gold:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, "金币不足500!"))
return
for k in marryTotalInfo.listAttends:
if k.uid == player.uid:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '不可重复报名!'))
return
player.addGold(gold * -1, True)
itemObj = player.itemCtrl.addItemByCfgId(item1)
if not itemObj:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '系统忙!'))
# return
itemObj2 = player.itemCtrl.addItemByCfgId(item2)
if not itemObj2:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '系统忙!'))
#return
ItemHandler.processQueryPkg(session)
# 增加总礼金，添加到列表
marryTotalInfo.totalGold += gold
#playerTmpInfo = MarryModel.PlayerMarryInfo()
#playerTmpInfo.setPlayerMarryInfo(player)
playerTmpInfo = MsgDef.MarriagePlayerMsg(player.uid, player.name,
player.job, player.gender,
player.level)
marryTotalInfo.listAttends.append(playerTmpInfo)
DbService.getPlayerService().updateMarry(marryTotalInfo)
#(opstype, player, flag = 0, delTime = 0, msg = '', gold = 0, skillId = 0, marryTotalInfo = None):
ret_msg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED, 0, '', gold, 0,
marryTotalInfo)
addItem2MarryPlayerMsg(ret_msg, itemObj, 1)
addItem2MarryPlayerMsg(ret_msg, itemObj2, 1)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_NEW_LIST:
# 新房列表
retMsg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED, 0, '', 0)
allMarriage = MarryModel.getAllMarriage()
for k, marryTotalInfo in allMarriage.iteritems():
#if marryTotalInfo.flagWeding != MsgDef.WeddingFlagCmd.WEDDING_APPLYED and marryTotalInfo.flagWeding != MsgDef.WeddingFlagCmd.WEDDING_FINISH:
# continue
if len(marryTotalInfo.coupleData
) == 2 and marryTotalInfo.coupleData[
0].status == MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED:
marryMsg = processMarriageVisitListBaseInfo(
marryTotalInfo.marryId, marryTotalInfo.coupleData[0],
marryTotalInfo.coupleData[1], marryTotalInfo.tmWedding)
retMsg.listVisitHouseInfo.append(marryMsg)
pass
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, retMsg)
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_VISIT_HOUSE:
# 我要参观其他新房
mId = msg.marryId
allMarriage = MarryModel.getAllMarriage()
marryInfo = allMarriage.get(mId)
if not marryInfo:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '结婚ID:%d不存在！' % (mId)))
return
mItems = []
for k, xItem in marryInfo.listSetItems.iteritems():
#mItems.append(xItem)
mItems.append(MsgDef.MarriageItem(k, xItem.get('itemCfgId', 0)))
marryMsg = processMarriageVisitListBaseInfo(mId,
marryInfo.coupleData[0],
marryInfo.coupleData[1],
marryInfo.tmWedding,
mItems)
retMsg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED, 0, '', 0)
retMsg.otherHouseInfo = marryMsg
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, retMsg)
ffext.dump('xxx', retMsg)
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_SET_HOUSE_ITEM:
# 装点新房
if not player.isMarry():
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, "请先结婚!"))
return
if msg.housePos < MsgDef.MarriageHousePos.MARRY_HOUSE_POS_1 or \
msg.housePos > MsgDef.MarriageHousePos.MARRY_HOUSE_POS_6:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, "位置错误!"))
return
itemToSetCfgId = 0
item = player.itemCtrl.getItem(msg.houseItemId)
if item:
itemToSetCfgId = item.itemCfg.cfgId
player.itemCtrl.delItem(msg.houseItemId)
else:
itemToSetCfgId = msg.houseItemId
setItemCfg = ItemModel.getItemMgr().getCfgByCfgId(itemToSetCfgId)
if not setItemCfg:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(
opstype, cmd,
"Item Id not exists! %d" % (msg.houseItemId)))
return
setItemHaveNum = player.itemCtrl.countItemNumbyCfgId(
itemToSetCfgId)
if setItemHaveNum < 1:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, "You do not have Item!"))
return
# 删除道具
player.itemCtrl.subItemNumByCfgId(itemToSetCfgId, 1)
# 设置到marriageCtl.marryTotalInfo
player.marriageCtrl.marryTotalInfo.addSetItem(msg.housePos,
itemToSetCfgId)
ret_msg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED, 0, '', 0)
#addItem2MarryPlayerMsgEx(ret_msg, msg.housePos, itemToSetCfgId)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
#更新数据库
itemStr = player.marriageCtrl.marryTotalInfo.toJson4SetItems()
extraStr = player.marriageCtrl.marryTotalInfo.toJson4Extra()
DbService.getPlayerService().updateMarryItem(
player.uid, player.marriageCtrl.marryId, itemStr, extraStr)
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_LEARN_COUPLE_SKILL:
# 学习夫妻技能
skillLevel = 1
retErr = player.skillCtrl.learnSkill(WEDDING_SKILL_ID, skillLevel)
if retErr:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(
opstype, cmd,
'学习技能%d失败，原因:%s!' % (WEDDING_SKILL_ID, retErr)))
return
session.sendMsg(MsgDef.ServerCmd.LEARN_SKILL,
MsgDef.LearnSkillRet(WEDDING_SKILL_ID, skillLevel))
retMsg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED, 0, '', 0,
WEDDING_SKILL_ID)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, retMsg)
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_DIVORCE_NORMAL:
# 和谐离婚 | 已婚-离婚中-（update消息）-未婚
if player.marriageCtrl.marryFlag != MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '不可以离婚!'))
return
marryTotalInfo = player.marriageCtrl.marryTotalInfo
myMarryInfo = player.marriageCtrl.marryTotalInfo.getInfoByGender(
player.gender)
if not myMarryInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '未知错误!'))
return
mateMarryInfo = player.marriageCtrl.marryTotalInfo.getInfoByAnotherGender(
player.gender)
if not mateMarryInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '未知错误!!'))
return
matePlayer = player.mapObj.getPlayerById(mateMarryInfo.uid)
#ffext.dump('mateplayer', matePlayer)
if not matePlayer:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '配偶没有在线!'))
return
player.tmpInfo['_marry_divorce_apply_'] = True
if matePlayer.tmpInfo.get('_marry_divorce_apply_') == None:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '等待配偶确认!'))
ret_msg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING, 0, '', 0)
if ret_msg.baseInfo.coupleData[0].uid == player.uid:
ret_msg.baseInfo.coupleData[
0].status = MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING
else:
ret_msg.baseInfo.coupleData[
1].status = MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING
#if ret_msg.baseInfo.coupleData[0].statu != ret_msg.baseInfo.coupleData[1].statu:
#ret_msg.baseInfo.coupleData[0].status = MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED
#ret_msg.baseInfo.coupleData[1].status = MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
matePlayer.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
return
player.tmpInfo['_marry_divorce_apply_'] = None
matePlayer.tmpInfo['_marry_divorce_apply_'] = None
myMarryInfo.status = MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING
mateMarryInfo.status = MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING
allFlag = True
delTime = ffext.getTime() + WEDDING_END_INTERVAL
# 发送回包
ret_msg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING, 0, '', 0)
if allFlag:
ret_msg.delTime = delTime
player.skillCtrl.deleteSkill(WEDDING_SKILL_ID, True)
matePlayer.skillCtrl.deleteSkill(WEDDING_SKILL_ID, True)
from handler import SkillHandler
SkillHandler.processQuerySkill(session)
SkillHandler.processQuerySkill(matePlayer.session)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
matePlayer.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
#离婚确定定时器
def divorceCB():
MarryModel.handleTimerDivorce(marryTotalInfo.marryId)
if allFlag:
# 对方也和谐离婚， 定时器开始
if WEDDING_END_INTERVAL == 1:
ffext.timer(WEDDING_END_INTERVAL * 100, divorceCB)
else:
ffext.timer(WEDDING_END_INTERVAL * 1000, divorceCB)
marryTotalInfo.tmEndWedding = delTime
DbService.getPlayerService().updateMarry(
player.marriageCtrl.marryTotalInfo)
elif opstype == MsgDef.MarriageClientCmd.MARRY_DIVORCE_QUIT: #取消离婚
myMarryInfo = player.marriageCtrl.marryTotalInfo.getInfoByGender(
player.gender)
if myMarryInfo.status != MsgDef.MarryStatusCmd.MARRY_STATUS_DIVORCING:
if player.tmpInfo.get('_marry_divorce_apply_') != None:
player.tmpInfo['_marry_divorce_apply_'] = None
ret_msg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED, 0, '')
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
mateInfo = player.marriageCtrl.marryTotalInfo.getInfoByAnotherGender(
player.gender)
matePlayer = player.mapObj.getPlayerById(mateInfo.uid)
if matePlayer:
matePlayer.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG,
ret_msg)
return
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '未申请和谐离婚!'))
return
myMarryInfo.status = MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED
mateInfo = player.marriageCtrl.marryTotalInfo.getInfoByAnotherGender(
player.gender)
mateInfo.status = MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED
DbService.getPlayerService().updateMarry(
player.marriageCtrl.marryTotalInfo)
# 发送回包
ret_msg = processMarryOpsMsgRet(
opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED, 0, '')
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
return
elif opstype == MsgDef.MarriageClientCmd.MARRY_DIVORCE_FORCE:
# 强制离婚 | 已婚-未婚
if player.marriageCtrl.marryFlag != MsgDef.MarryStatusCmd.MARRY_STATUS_MARRIED:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '不可以离婚!'))
return
needGold = 1000000
if player.gold < needGold:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, "金币不足!"))
return
marryTotalInfo = player.marriageCtrl.marryTotalInfo
if not marryTotalInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '未领取任务！'))
return
oldMarryId = marryTotalInfo.marryId
anotherInfo = marryTotalInfo.getInfoByAnotherGender(player.gender)
oldMateId = anotherInfo.uid
matePlayer = player.mapObj.getPlayerById(anotherInfo.uid)
player.addGold(needGold * -1, True)
matePlayer.addGold(needGold, True)
MarryModel.getMarryMgr().delMarryById(marryTotalInfo.marryId)
mateSession = None
from handler import SkillHandler
if matePlayer:
mateSession = matePlayer.session
matePlayer.marriageCtrl.divorceForce()
matePlayer.skillCtrl.deleteSkill(WEDDING_SKILL_ID, True)
SkillHandler.processQuerySkill(mateSession)
player.marriageCtrl.divorceForce()
player.skillCtrl.deleteSkill(WEDDING_SKILL_ID, True)
SkillHandler.processQuerySkill(session)
# 发送回包
ret_msg = processMarryOpsMsgRet(opstype, session.player,
MsgDef.MarryStatusCmd.MARRY_STATUS_NOT,
0, '', needGold)
session.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
if mateSession:
#up_msg = processMarriageUpdateRet(opstype, player, MsgDef.MarryStatusCmd.MARRY_STATUS_NOT, None)
mateSession.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg)
return
# 更新数据库
DbService.getPlayerService().updateMarryDivorce(oldMarryId)
DbService.getPlayerService().updateMarryDivorcePlayer(player.uid)
DbService.getPlayerService().updateMarryDivorcePlayer(oldMateId)
return
def processQieCuoReq(session, msg):
player = session.player
if msg.opstype == 0:#0表示请求切磋 1表示同意 2表示拒绝
destPlayer = player.mapObj.getPlayerById(msg.uidarg)
if not destPlayer:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '对手不在线'))
return
playerInfo = MsgDef.BrotherPlayerMsg()
buildPlayerInfo(playerInfo, player)
retMsg = MsgDef.QieCuoRet(msg.opstype, playerInfo)#0表示请求切磋 1表示同意 2表示拒绝 3表示 切磋状态消失
destPlayer.sendMsg(MsgDef.ServerCmd.QIECUO_OPS, retMsg)
elif msg.opstype == 1:
destPlayer = player.mapObj.getPlayerById(msg.uidarg)
if not destPlayer:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '对手不在线'))
return
playerInfo = MsgDef.BrotherPlayerMsg()
buildPlayerInfo(playerInfo, player)
retMsg = MsgDef.QieCuoRet(msg.opstype, playerInfo)#0表示请求切磋 1表示同意 2表示拒绝 3表示 切磋状态消失
destPlayer.sendMsg(MsgDef.ServerCmd.QIECUO_OPS, retMsg)
playerInfo = MsgDef.BrotherPlayerMsg()
buildPlayerInfo(playerInfo, destPlayer)
retMsg = MsgDef.QieCuoRet(msg.opstype, playerInfo)#0表示请求切磋 1表示同意 2表示拒绝 3表示 切磋状态消失
session.sendMsg(MsgDef.ServerCmd.QIECUO_OPS, retMsg)
player.ctrlQieCuo.setQieCuoPlayer(destPlayer)
destPlayer.ctrlQieCuo.setQieCuoPlayer(player)
ref1 = player.ctrlQieCuo.playerRefQieCuo
ref2 = destPlayer.ctrlQieCuo.playerRefQieCuo
def cb():
player1 = ref1()
player2 = ref2()
if player1 and player1.mapObj != None:
if not player2 or player2.mapObj == None:#player1 win
winQieCuo(player1)
return
if player2.ctrlQieCuo.startMap != player2.mapname:
winQieCuo(player1)
return
dist = Base.distance(player2.x, player2.y, player2.ctrlQieCuo.startX, player2.ctrlQieCuo.startY)
if dist > Base.QIECUO_MAX_RANGE:
if player2.ctrlQieCuo.warnTimes == 0:
player2.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '警告!切磋出界3秒后将会被判输!'))
player2.ctrlQieCuo.warnTimes += 1
if player2.ctrlQieCuo.warnTimes == 4:
winQieCuo(player1)
return
else:
player2.ctrlQieCuo.warnTimes = 0
if player2.hp == 1:
winQieCuo(player1)
return
if player1.ctrlQieCuo.startMap != player1.mapname:
winQieCuo(player2)
return
dist = Base.distance(player1.x, player1.y, player1.ctrlQieCuo.startX, player1.ctrlQieCuo.startY)
if dist > Base.QIECUO_MAX_RANGE:
if player1.ctrlQieCuo.warnTimes == 0:
player1.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '警告!出界3秒后将会被判输!'))
player1.ctrlQieCuo.warnTimes += 1
if player1.ctrlQieCuo.warnTimes == 4:
winQieCuo(player2)
return
else:
player1.ctrlQieCuo.warnTimes = 0
if player1.hp == 1:
winQieCuo(player2)
return
ffext.dump('check win ...')
ffext.timer(1000, cb)
else:
if player2:
winQieCuo(player2)
return
return
ffext.timer(1000, cb)
elif msg.opstype == 2:
destPlayer = player.mapObj.getPlayerById(msg.uidarg)
if not destPlayer:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, buildErrMsg(MsgDef.ClientCmd.QIECUO_OPS, '对手不在线'))
return
playerInfo = MsgDef.BrotherPlayerMsg()
buildPlayerInfo(playerInfo, player)
retMsg = MsgDef.QieCuoRet(msg.opstype, playerInfo)#0表示请求切磋 1表示同意 2表示拒绝 3表示 切磋状态消失
destPlayer.sendMsg(MsgDef.ServerCmd.QIECUO_OPS, retMsg)
return
