def processBrotherDownline2(session):
#先判断用户是否有结义,没有结义，要判断用户是否有结义申请。有结义申请，调用结义申请归置函数
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
if TeamModel.BrotherFlag.flag1 == session.player.brotherCtrl.brotherFlag:
return
memberSession1 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[0])
memberSession2 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[1])
memberSession1.player.brotherCtrl.refuseBrotherInviter()
memberSession1.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(MsgDef.BrotherClientCmd.DOWN_LINE_BROTHER,
session.player, [], True, 0))
memberSession2.player.brotherCtrl.refuseBrotherInviter()
memberSession2.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(MsgDef.BrotherClientCmd.DOWN_LINE_BROTHER,
session.player, [], True, 0))
return
#用户有结义信息，在下线的时候，刷新session中存储的用户信息
for key, val in brotherInfo.getBrotherMember().iteritems():
if session.player.uid == val.uid:
val.level = session.player.level
return
def handleTimerWedding(marryId):
marryTotalInfo = getMarryMgr().getMarryTotalInfo(marryId)
if not marryTotalInfo:
return
#ffext.dump('handleTimerWedding', marryTotalInfo)
#举行婚礼
playerSess = ffext.getSessionMgr().findByUid(marryTotalInfo.coupleData[0].uid)
marryPlayerSess = ffext.getSessionMgr().findByUid(marryTotalInfo.coupleData[1].uid)
if not playerSess or not marryPlayerSess:
marryTotalInfo.flagWeding = MsgDef.WeddingFlagCmd.WEDDING_FAIL
DbService.getPlayerService().updateMarry(marryTotalInfo)
return
player = playerSess.player
from handler import MarryHandler
ret_msg2 = MarryHandler.processMarryOpsMsgRet(MsgDef.MarriageClientCmd.MARRY_WEDDING_START, player)
#ffext.dump('marryTotalInfo.listAttends', marryTotalInfo.listAttends)
for k in marryTotalInfo.listAttends:
ret_msg2.argPlayer = k
prizePlayer = player.mapObj.getPlayerById(k.uid)
if prizePlayer:
ret_msg2.argPlayer = k
ret_msg2.gold = marryTotalInfo.totalGold
prizePlayer.addGold(marryTotalInfo.totalGold)
#清楚婚礼进行数据
marryTotalInfo.totalGold = 0
marryTotalInfo.listAttends = []
break
marryTotalInfo.flagWeding = MsgDef.WeddingFlagCmd.WEDDING_FINISH
player.broadcast(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, ret_msg2)
#状态变化，更新数据库
DbService.getPlayerService().updateMarry(marryTotalInfo)
def onWeeklyNightEvent(self):
ffext.dump(
"***************** New Week Process Begin ... ******************:",
ffext.getTime())
#所有在线玩家对象，每日refresh
ffext.getSessionMgr().foreach(self.weeklyRefresh4Session)
ffext.dump(
"***************** New Week Process End ... ******************:",
ffext.getTime())
return True
def processBrotherDownline(session):
#先判断用户是否有结义,没有结义，要判断用户是否有结义申请。有结义申请，调用结义申请归置函数
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
brotherInfo = session.player.brotherCtrl.tmpBrotherInfo
allPlayers = brotherInfo.getPlayers()
for k in allPlayers:
if k:
k.brotherCtrl.tmpBrotherInfo = None
k.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(
MsgDef.BrotherClientCmd.DOWN_LINE_BROTHER,
session.player, [], True, 0))
k.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(
MsgDef.BrotherClientCmd.DOWN_LINE_BROTHER,
MsgDef.ServerCmd.BROTHER_OPS_MSG,
'%s下线，结义状态解除。' % (session.player.name)))
return
#用户有结义信息，在下线的时候，刷新session中存储的用户信息
for key, val in brotherInfo.getBrotherMember().iteritems():
if session.player.uid == val.uid:
val.level = session.player.level
else:
memberSession1 = ffext.getSessionMgr().findByUid(val.uid)
if memberSession1:
memberSession1.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(
MsgDef.BrotherClientCmd.DOWN_LINE_BROTHER,
session.player, [], False, 0))
def onMiddleNightEvent(self):
ffext.dump(
"***************** New Day Process Begin ... ******************:",
ffext.getTime())
#添加每日凌晨更新时间到这里，依次处理
self.updateRefreshTime()
#每日排行榜刷新
RankModel.getRankMgr().dailyRefresh()
#所有在线玩家对象，每日refresh
ffext.getSessionMgr().foreach(self.dailyRefresh4Session)
ffext.dump(
"***************** New Day Process End ... ******************:",
ffext.getTime())
return True
def processOffline(session): #MARRY_OFFLINE
cmd = 1
opstype = 2
player = session.player
#ffext.error('111 %d'%(player.uid))
#ffext.error('111 1 %d'%(player.uid))
opstype = 17 #MsgDef.MarriageClientCmd.MARRY_OFFLINE
#ffext.error('222 %d'%(player.uid))
marryTotalInfo = player.marriageCtrl.marryTotalInfo
#ffext.error('333 %d'%(player.uid))
if not marryTotalInfo:
marryTotalInfo = player.tmpInfo.get('_marry_task_apply_')
#ffext.error('111 44 %d'%(player.uid))
if marryTotalInfo:
#ffext.error('111 5 %d'%(player.uid))
anotherInfo = marryTotalInfo.getInfoByAnotherGender(player.gender)
mateSession = ffext.getSessionMgr().findByUid(anotherInfo.uid)
if mateSession:
#ffext.error(' 6 %d'%(player.uid))
retMsg = processMarryOpsMsgRet(opstype, player, 0, 0, '', 0)
mateSession.sendMsg(MsgDef.ServerCmd.MARRIAGE_OPS_MSG, retMsg)
if mateSession.player.tmpInfo.get(
'_marry_task_apply_') == marryTotalInfo:
mateSession.player.tmpInfo['_marry_task_apply_'] = None
return
def processHelpAttackReq(session, msg = None):
player = session.player
if msg.opstype == 0:
playerInfo = MsgDef.BrotherPlayerMsg()
buildPlayerInfo(playerInfo, player)
retMsg = MsgDef.HelpAttackRet(0, playerInfo)
#结婚的
hasSendUids = {}
if player.isMarry():
marryTotalInfo = player.marriageCtrl.marryTotalInfo
other = marryTotalInfo.getInfoByAnotherGender(player.gender)
ffext.dump('help', player.gender, other)
if other:
#otherPlayer = player.mapObj.getPlayerById(other.uid)
otherSession = ffext.getSessionMgr().findByUid(other.uid)
if otherSession:
hasSendUids[other.uid] = True
otherPlayer = otherSession.player
otherPlayer.sendMsg(MsgDef.ServerCmd.HELP_ATTACK_OPS, retMsg)
#
brotherInfo = player.brotherCtrl.brotherInfo
if None != brotherInfo:
# 判断三个人是否同时在线
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != memberSession:
memberSession.sendMsg(MsgDef.ServerCmd.HELP_ATTACK_OPS, retMsg)
return
# team = TeamModel.getTeamMgr().getTeamById(player.teamCtrl.teamID)
# if team:
# for key, valdata in team.getTeamMember().iteritems():
# if hasSendUids.get(valdata.uid) == True or valdata.uid == player.uid:
# continue
# else:
# hasSendUids[other.uid] = True
# otherSession = ffext.getSessionMgr().findByUid(valdata.uid)
# if otherSession:
# otherPlayer = otherSession.player
# playerInfo = MsgDef.BrotherPlayerMsg()
# buildPlayerInfo(playerInfo, player)
# otherPlayer.sendMsg(MsgDef.ServerCmd.HELP_ATTACK_OPS, MsgDef.HelpAttackRet(0, playerInfo))
elif msg.opstype == 1:
otherSession = ffext.getSessionMgr().findByUid(msg.uidArg)
if otherSession:
otherPlayer = otherSession.player
otherPlayer.mapObj.playerEnterMap(player, otherPlayer.x, otherPlayer.y)
return
def processMarriageUpdateRet(opstype, mateP, st, goldP):
ret_msg = MsgDef.MarriageUpdateRet()
ret_msg.opstype = opstype
if mateP:
ret_msg.matePlayer = processMarryPlayerMsg(
mateP,
ffext.getSessionMgr().isPlayerOnline(mateP.uid))
else:
ret_msg.matePlayer = {}
ret_msg.status = st
if goldP:
ret_msg.goldPlayer = processMarryPlayerMsg(
goldP,
ffext.getSessionMgr().isPlayerOnline(goldP.uid))
else:
ret_msg.goldPlayer = {}
return ret_msg
def kickoff(session, args):
if len(args) < 2:
ret_msg.chatMsg = '参数 @kickoff playername'
session.player.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
sess = ffext.getSessionMgr().getSessionByName(args[1])
if sess:
sess.close()
return
def processBrotherDelay(session, flag, opstype, cmd, ret_msg):
#先判断用户是否及时同意结义（三个用户，存在有人结义状态仍然为1）
#获取结义中三个玩家的session
memberSession1 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[0])
memberSession2 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[1])
if flag == session.player.brotherCtrl.brotherFlag or flag == memberSession1.player.brotherCtrl.brotherFlag or flag == memberSession2.player.brotherCtrl.brotherFlag:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, ret_msg))
memberSession1.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, ret_msg))
memberSession2.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, ret_msg))
session.player.brotherCtrl.refuseBrotherInviter()
memberSession1.player.brotherCtrl.refuseBrotherInviter()
memberSession2.player.brotherCtrl.refuseBrotherInviter()
return
def testarena(session, args):
if len(args) < 3:
ret_msg.chatMsg = '参数 @testarena uid1 uid2'
session.player.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
from model import ArenaModel
sess = ffext.getSessionMgr().findByUid(long(args[1]))
if not sess:
sess = session
ArenaModel.getArenaMgr().createArena(sess.player, long(args[2]))
def doSendMailToPlayer(player, toUid, sendType, title, msg, listAtt = None):
if not listAtt:
listAtt = []
tgtPlayer = ffext.getSessionMgr().findByUid(toUid)
newMail = createNewMail(player, sendType, title, msg, listAtt)
if not tgtPlayer:
# 目标玩家-离线
ffext.dump('tgtplayer', tgtPlayer)
saveMailOffline(toUid, newMail)
else:
# 玩家在线
tgtPlayer.player.mailCtrl.addMail(newMail)
return
def cbEnd():
rankWarInfo = self.allGuildRankWarVSInfo.pop(rankWarId, None)
if not rankWarInfo:
return
rankWarInfo.tmRankWarStart = 0
retMsg = MsgDef.GuildRankWarOpsRet(
MsgDef.GuildRankWarOpsCmd.RANKWAR_END,
rankWarInfo.tmRankWarStart)
retMsg.winGuildId = 0
if rankWarInfo.guildWin:
retMsg.winGuildId = rankWarInfo.guildWin
elif rankWarInfo.guildScore1 > rankWarInfo.guildScore2:
rankWarInfo.guildWin = rankWarInfo.guild1.guildID
retMsg.winGuildId = rankWarInfo.guild1.guildID
elif rankWarInfo.guildScore1 < rankWarInfo.guildScore2:
rankWarInfo.guildWin = rankWarInfo.guild2.guildID
retMsg.winGuildId = rankWarInfo.guild2.guildID
elif rankWarInfo.guildScore1 == rankWarInfo.guildScore2:
allHp1 = 0
allHp2 = 0
for k, v in rankWarInfo.guildTeam1.iteritems():
memberSession = ffext.getSessionMgr().findByUid(k)
if memberSession:
member = memberSession.player
allHp1 += member.hp
for k, v in rankWarInfo.guildTeam2.iteritems():
memberSession = ffext.getSessionMgr().findByUid(k)
if memberSession:
member = memberSession.player
allHp2 += member.hp
if allHp1 > allHp2:
rankWarInfo.guildWin = rankWarInfo.guild1.guildID
retMsg.winGuildId = rankWarInfo.guild1.guildID
elif allHp1 < allHp2:
rankWarInfo.guildWin = rankWarInfo.guild2.guildID
retMsg.winGuildId = rankWarInfo.guild2.guildID
if not retMsg.winGuildId:
DbService.getGuildService().updateRankWarWin(
0, rankWarInfo.guildId1, rankWarInfo.guildId2)
for k, v in rankWarInfo.guildTeam1.iteritems():
memberSession = ffext.getSessionMgr().findByUid(k)
memberSession.sendMsg(cmd, retMsg)
for k, v in rankWarInfo.guildTeam2.iteritems():
memberSession = ffext.getSessionMgr().findByUid(k)
memberSession.sendMsg(cmd, retMsg)
else:
DbService.getGuildService().updateRankWarWin(
0, rankWarInfo.getAnotherGuild(retMsg.winGuildId))
if retMsg.winGuildId == rankWarInfo.guild1.guildID:
for k, v in rankWarInfo.guildTeam1.iteritems():
memberSession = ffext.getSessionMgr().findByUid(k)
memberSession.sendMsg(cmd, retMsg)
elif retMsg.winGuildId == rankWarInfo.guild2.guildID:
for k, v in rankWarInfo.guildTeam1.iteritems():
memberSession = ffext.getSessionMgr().findByUid(k)
memberSession.sendMsg(cmd, retMsg)
def processBrotherDel(session, opstype):
brotherInfo = session.player.brotherCtrl.brotherInfo
#if brotherInfo.flag:
# return
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != memberSession:
memberSession.player.brotherCtrl.delBrother(memberSession.player)
memberSession.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, memberSession.player, [],
True, 0))
sendBroList(memberSession)
TeamModel.getBrotherMgr().delBrother(brotherInfo.bid)
#此处为及时自行数据库删除操作
#########
#########
#########
#########
#########
return
def cb(ret):
for row in ret.result:
memberUid = int(row[0])
guildId = int(row[1])
memberSession = ffext.getSessionMgr().findByUid(memberUid)
if memberSession:
member = memberSession.player
#询问是否进入地图
retMsg.guildId = guildId
retMsg.mapname = mapxy[0]
retMsg.x = mapxy[1]
retMsg.y = mapxy[2]
memberSession.sendMsg(cmd, retMsg)
import time
time.sleep(10)
if guildId == rankWarInfo.guildId1 and member.mapname == mapxy[
0]:
member.modeAttack = MsgDef.EATTACK_MODE.PEACE
rankWarInfo.guildTeam1[memberUid] = member
elif guildId == rankWarInfo.guildId2 and member.mapname == mapxy[
0]:
member.modeAttack = MsgDef.EATTACK_MODE.PEACE
rankWarInfo.guildTeam2[memberUid] = member
self.allGuildRankWarVSInfo[rankWarInfo.warId] = rankWarInfo
def sendBroList(session, opstype=MsgDef.BrotherClientCmd.GET_BROTHERLIST):
allBrotherInfo = []
#先判断用户是否有结义
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
session.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
return
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if None == memberSession:
online = False
else:
online = True
allBrotherInfo.append(processBrotherOpsMsg(val, online))
if brotherInfo.flag:
delBrotherTime = 0
else:
delBrotherTime = brotherInfo.getBrotherExtraByKey('delTime')
session.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, allBrotherInfo,
brotherInfo.flag, delBrotherTime))
def processListFriend(session, msg):
#声明好友列表以FriendListMsgRet格式传输，客户端识别指令为FRIENDLIST_MSG传输格式
#print(msg)
ret_msg = MsgDef.FriendListMsgRet()
ret_msg.opstype = msg.opstype
ret_msg.allPlayerInfo = []
ret_msg.allEnemyInfo = []
ret_msg.allShieldInfo = []
if msg.opstype == MsgDef.FriendListClientCmd.GET_FRIENDLIST:
online = True
#遍历allFriend字典，获取好友属性
for uid, val in session.player.friendCtrl.getFriend().iteritems():
if None == ffext.getSessionMgr().findByUid(val.uid):
online = False
else:
online = True
#将好友信息赋值，传递给客户端
ret_msg.allPlayerInfo.append(
processFriendPlayerMsg(val.uid, val.name, val.job, val.gender,
val.level, online))
for uid, val in session.player.friendCtrl.getEnemy().iteritems():
if None == ffext.getSessionMgr().findByUid(val.uid):
online = False
else:
online = True
#将仇人信息赋值，传递给客户端
ret_msg.allEnemyInfo.append(
processFriendPlayerMsg(val.uid, val.name, val.job, val.gender,
val.level, online))
for uid, val in session.player.friendCtrl.getShieldPerson().iteritems(
):
if None == ffext.getSessionMgr().findByUid(val.uid):
online = False
else:
online = True
#将屏蔽信息赋值，传递给客户端
ret_msg.allShieldInfo.append(
processFriendPlayerMsg(val.uid, val.name, val.job, val.gender,
val.level, online))
session.sendMsg(MsgDef.ServerCmd.FRIENDLIST_MSG, ret_msg)
return
# if msg.opstype == MsgDef.FriendListClientCmd.GET_FRIENDLIST_TEMP:
# #遍历allFriend字典，获取好友属性
# for uid, val in session.player.friendCtrl.getFriendTemp().iteritems():
# ret_msg.allPlayerInfo.append(processFriendPlayerMsg(val.uid, val.name))
# session.sendMsg(MsgDef.ServerCmd.FRIENDLIST_MSG, ret_msg)
# return
#仇人追击
if msg.opstype == MsgDef.FriendListClientCmd.GET_ENEMY:
enemyUid = msg.uid
for uid, val in session.player.friendCtrl.getEnemy().iteritems():
if uid == enemyUid:
enemyPlayer = ffext.getSessionMgr().findByUid(enemyUid).player
if None == enemyPlayer:
online = False
retErr = Base.lang('仇人处于离线状态!')
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
buildErrMsg(MsgDef.FriendListClientCmd.GET_ENEMY,
retErr))
return
else:
online = True
ret_msg.allEnemyInfo.append(
processFriendPlayerMsg(val.uid, val.name, val.job,
val.gender, val.level, online,
enemyPlayer.mapname,
enemyPlayer.x, enemyPlayer.y))
session.sendMsg(MsgDef.ServerCmd.FRIENDLIST_MSG, ret_msg)
return
else:
retErr = Base.lang('仇人不存在!')
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
buildErrMsg(MsgDef.FriendListClientCmd.GET_ENEMY, retErr))
return
if msg.opstype == MsgDef.FriendListClientCmd.JUMP_ENEMY:
enemyUid = msg.uid
for uid, val in session.player.friendCtrl.getEnemy().iteritems():
if uid == enemyUid:
enemyPlayer = ffext.getSessionMgr().findByUid(enemyUid).player
if None == enemyPlayer:
online = False
retErr = Base.lang('仇人处于离线状态!')
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
buildErrMsg(MsgDef.FriendListClientCmd.GET_ENEMY,
retErr))
return
else:
online = True
mapname = enemyPlayer.mapname
x = enemyPlayer.x
y = enemyPlayer.y
mapObj = MapMgr.getMapMgr().allocMap(mapname)
if not mapObj:
retErr = Base.lang('地图不存在!')
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
buildErrMsg(MsgDef.FriendListClientCmd.JUMP_ENEMY,
retErr))
return
mapObj.playerEnterMap(session.player, x, y)
return
else:
retErr = Base.lang('仇人不存在!')
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
buildErrMsg(MsgDef.FriendListClientCmd.GET_ENEMY, retErr))
return
def processBrotherOps2(session, msg): #0表示邀请别人一起结义
opstype = msg.opstype
cmd = MsgDef.ClientCmd.BROTHER_OPS
#ffext.dump('processBrotherrOps', msg)
if opstype == MsgDef.BrotherClientCmd.INVITE_ADD_BROTHER:
#获取用户邀请结义的ID
uid1 = msg.uid1
uid2 = msg.uid2
uid = session.player.uid
memberSession1 = ffext.getSessionMgr().findByUid(uid1)
memberSession2 = ffext.getSessionMgr().findByUid(uid2)
#判断用户是否满足结义条件
if not processCheckAddBrother(session, memberSession1, memberSession2,
opstype, cmd):
return
if TeamModel.BrotherFlag.flag1 != session.player.brotherCtrl.brotherFlag or TeamModel.BrotherFlag.flag1 != memberSession1.player.brotherCtrl.brotherFlag or TeamModel.BrotherFlag.flag1 != memberSession2.player.brotherCtrl.brotherFlag:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户不满足结义条件。'))
return
#执行邀请代码，将用户加入至待验证列表
session.player.brotherCtrl.AddBrotherInviter(uid1, uid2)
memberSession1.player.brotherCtrl.AddBrotherInviter(uid, uid2)
memberSession2.player.brotherCtrl.AddBrotherInviter(uid1, uid)
#将邀请信息发给对方
allBrotherInfo = []
allBrotherInfo.append(processBrotherOpsMsg(session.player, True))
allBrotherInfo.append(processBrotherOpsMsg(memberSession1.player,
True))
allBrotherInfo.append(processBrotherOpsMsg(memberSession2.player,
True))
session.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, allBrotherInfo,
True, 0))
memberSession1.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, allBrotherInfo,
True, 0))
memberSession2.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, allBrotherInfo,
True, 0))
#15秒后如果用户未确定结义状态改变，则将结义状态初始化（以后添加）
def cb():
processBrotherDelay(session, TeamModel.BrotherFlag.flag2, opstype,
cmd, '存在用户未及时同意结义，所有结义归零')
return
#ffext.timer(15 * 1000, cb)
return
if msg.opstype == MsgDef.BrotherClientCmd.VERIFY_INVIT_ADD_BROTHER:
#判断用户是否满足结义条件
memberSession1 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[0])
memberSession2 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[1])
if not processCheckAddBrother(session, memberSession1, memberSession2,
opstype, cmd):
return
#同意结义
session.player.brotherCtrl.verifyBrotherInviter()
session.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
memberSession1.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
memberSession2.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
#15秒后如果用户未确定结义状态改变，则将结义状态初始化（以后添加）
def cb():
processBrotherDelay(session, TeamModel.BrotherFlag.flag3, opstype,
cmd, '存在用户未及时确认结义，所有结义归零')
return
#ffext.timer(15 * 1000, cb)
return
if msg.opstype == MsgDef.BrotherClientCmd.REFUSE_INVITT_ADD_BROTHER:
#此处应判断是否满足同意结义的条件
#拒绝结义
memberSession1 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[0])
memberSession2 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[1])
session.player.brotherCtrl.refuseBrotherInviter()
session.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
memberSession1.player.brotherCtrl.refuseBrotherInviter()
memberSession1.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
memberSession2.player.brotherCtrl.refuseBrotherInviter()
memberSession2.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
return
#用户确认结义
if msg.opstype == MsgDef.BrotherClientCmd.CONFIRM_INVIT_ADD_BROTHER:
#判断用户是否满足结义条件
memberSession1 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[0])
memberSession2 = ffext.getSessionMgr().findByUid(
session.player.brotherCtrl.inviter[1])
if not processCheckAddBrother(session, memberSession1, memberSession2,
opstype, cmd):
return
if TeamModel.BrotherFlag.flag4 != session.player.brotherCtrl.brotherFlag:
session.player.brotherCtrl.confirmBrotherInviter()
session.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
memberSession1.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
memberSession2.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True, 0))
if TeamModel.BrotherFlag.flag4 == memberSession1.player.brotherCtrl.brotherFlag and TeamModel.BrotherFlag.flag4 == memberSession2.player.brotherCtrl.brotherFlag:
bid = TeamModel.getBrotherMgr().addBrotherList(
session.player, memberSession1.player, memberSession2.player)
session.player.brotherCtrl.AddBrother(bid)
memberSession1.player.brotherCtrl.AddBrother(bid)
memberSession2.player.brotherCtrl.AddBrother(bid)
sendBroList(session)
sendBroList(memberSession1)
sendBroList(memberSession2)
return
#用户强制退出结义
if opstype == MsgDef.BrotherClientCmd.QUIT_BROTHER:
#先判断用户是否有结义
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户没有结义信息。'))
return
if session.player.gold < TeamModel.BROTHER_QUIT_GOLD:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '金钱不足，不能强制退出。'))
return
#扣除金钱
session.player.addGold(-TeamModel.BROTHER_QUIT_GOLD)
bid = brotherInfo.bid
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != memberSession:
memberSession.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True,
0))
memberSession.player.brotherCtrl.delBrother(
memberSession.player)
if val.uid == session.player.uid:
continue
else:
memberSession.player.addGold(TeamModel.BROTHER_QUIT_GOLD /
2)
else:
DbService.getPlayerService().updateGold(
val, TeamModel.BROTHER_QUIT_GOLD / 2)
TeamModel.getBrotherMgr().delBrother(bid)
return
#发送结义列表
if opstype == MsgDef.BrotherClientCmd.GET_BROTHERLIST:
sendBroList(session, opstype)
return
#用户协商退出结义（必须三个人同时在线）
if opstype == MsgDef.BrotherClientCmd.CONSULT_QUIT_BROTHER:
#先判断用户是否有结义
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户没有结义信息。'))
return
#判断三个人是否同时在线
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if None == memberSession:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户协议取消结义时，必须同时在线！'))
return
if TeamModel.BrotherFlag.flag5 != session.player.brotherCtrl.brotherFlag:
session.player.brotherCtrl.consultBrotherQuit()
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
memberSession.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], False,
0))
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if TeamModel.BrotherFlag.flag5 != memberSession.player.brotherCtrl.brotherFlag:
return
delTimeSec = 1
#修改结义状态
time = ffext.getTime() + delTimeSec
#time = ffext.getTime() + 2 * 3600 * 24
session.player.brotherCtrl.brotherInfo.addTime(time)
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
memberSession.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], False,
time))
def cb():
processBrotherDel(session, opstype)
return
ffext.timer(1 * 1000, cb)
#ffext.timer(2 * 3600 * 24 * 1000, cb)
return
#用户取消退出结义
if opstype == MsgDef.BrotherClientCmd.CANCLE_QUIT_BROTHER:
#先判断用户是否有结义
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户没有结义信息。'))
return
#判断是否需要取消
if brotherInfo.flag:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户没有协议解除结义信息。'))
return
brotherInfo.flag = True
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != memberSession:
memberSession.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True,
0))
memberSession.player.brotherCtrl.brotherFlag = TeamModel.BrotherFlag.flag4
#将倒计时数据从数据库中和session中删除
brotherInfo.delTime()
return
def processTeamOps(session, msg):
opstype = msg.opstype
cmd = MsgDef.ClientCmd.TEAMLIST_OPS
uid = msg.uid
memberSession = ffext.getSessionMgr().findByUid(uid)
#邀请别人进行组队
if opstype == MsgDef.TeamClientCmd.INVITE_ADD_TEAM:
if not (processCheckAddTeam(session, memberSession, opstype, cmd) and
processCheckMacTeamNum(session, memberSession, opstype, cmd)):
return
memberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(opstype, session.player, False))
#同意别人邀请，进行组队
if opstype == MsgDef.TeamClientCmd.VERIFY_INVIT_ADD_TEAM:
if not (processCheckAddTeam(session, memberSession, opstype, cmd) and
processCheckMacTeamNum(session, memberSession, opstype, cmd)):
return
#判断是加入队伍还是同意别人加入
if 0 != session.player.teamCtrl.teamID:
teamID = session.player.teamCtrl.teamID
#同意别人加入
memberSession.player.teamCtrl.setTeamID(teamID)
#将用户信息广播给已有成员
for key, val in TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMember().iteritems():
teamMemberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != teamMemberSession:
teamMemberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(
opstype, memberSession.player, False))
if val.uid == teamID:
leader = True
else:
leader = False
memberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(opstype, val, leader))
memberSession.player.teamCtrl.setTeamID(teamID)
TeamModel.getTeamMgr().getTeamById(teamID).addTeamMember(
memberSession.player)
else:
if 0 == memberSession.player.teamCtrl.teamID:
#两人均没有队伍，给对方创建队伍，并任命对方为队长
TeamModel.getTeamMgr().addTeam(memberSession.player)
memberSession.player.teamCtrl.setTeamID(
memberSession.player.uid)
teamID = memberSession.player.teamCtrl.teamID
#同意加入别人
session.player.teamCtrl.setTeamID(teamID)
#将用户信息广播给已有成员
for key, val in TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMember().iteritems():
teamMemberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != teamMemberSession:
teamMemberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(
opstype, session.player, False))
if val.uid == teamID:
leader = True
else:
leader = False
session.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(opstype, val, leader))
session.player.teamCtrl.setTeamID(teamID)
TeamModel.getTeamMgr().getTeamById(teamID).addTeamMember(
session.player)
return
#拒绝别人邀请
if opstype == MsgDef.TeamClientCmd.REFUSE_INVITT_ADD_TEAM:
memberSession = ffext.getSessionMgr().findByUid(uid)
#session.sendMsg(MsgDef.ServerCmd.TEAM_MSG, processTeamPlayerMsgRet(opstype, uid, '', 0, 0, 0, 0, 0, 0, 0, 0, 0, False))
if None != memberSession:
if session.player.uid == session.player.teamCtrl.teamID:
leader = True
else:
leader = False
memberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(opstype, session.player,
leader))
return
#删除队友CONFIRM_INVIT_ADD_BROTHER
if opstype == MsgDef.TeamClientCmd.DEL_TEAMPLAYER:
teamID = session.player.teamCtrl.teamID
if session.player.uid != teamID:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '您不是队长，进行队伍成员操作'))
return
if session.player.uid == uid:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '不能对自己进行操作，如想退出队伍，请使用退出队伍选项'))
return
#判断用户是否在队伍中(理论上应该客户端判断)
if None == TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMemberByUid(uid):
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户不在队伍中，无法删除。'))
return
#将队友从session中删除
TeamModel.getTeamMgr().getTeamById(teamID).delTeamMember(uid)
if None != memberSession:
memberSession.player.teamCtrl.setTeamID(0)
memberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(opstype, session.player, True))
for key, val in TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMember().iteritems():
teamMemberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != teamMemberSession:
teamMemberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(opstype,
memberSession.player,
False))
return
#退出组队（用户下线时也执行相同代码，如）
if opstype == MsgDef.TeamClientCmd.QUIT_TEAM:
teamID = session.player.teamCtrl.teamID
#判断自己是否加入队伍(理论上应该客户端判断teamID=0，不需要给客户端返回语句)
if 0 == teamID:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '没有队伍，不需要退出。'))
return
#判断自己是否为队长(队长退出时默认为队伍解散)
if session.player.uid == teamID:
for key, val in TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMember().iteritems():
teamMemberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != teamMemberSession:
teamMemberSession.player.teamCtrl.setTeamID(0)
teamMemberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(
opstype, session.player, True))
TeamModel.getTeamMgr().delTeam(teamID)
else:
for key, val in TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMember().iteritems():
teamMemberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != teamMemberSession:
teamMemberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgByPlayerRet(
opstype, session.player, False))
TeamModel.getTeamMgr().getTeamById(teamID).delTeamMember(
session.player.uid)
session.player.teamCtrl.setTeamID(0)
return
#更换队长
if opstype == MsgDef.TeamClientCmd.REPLACE_TEAMLEADER:
teamID = session.player.teamCtrl.teamID
if session.player.uid != teamID:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '您不是队长，无权进行更换队长操作'))
return
if None == TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMemberByUid(uid):
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '新任命的队长不在队伍中，无法任命'))
return
#向所有队员广播变更队长消息
for key, val in TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMember().iteritems():
teamMemberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != teamMemberSession:
teamMemberSession.player.teamCtrl.setTeamID(uid)
teamMemberSession.sendMsg(
MsgDef.ServerCmd.TEAM_MSG,
processTeamPlayerMsgRet(opstype, uid, '', 0, 0, 0, 0, 0, 0,
0, 0, 0, False))
#变更session中存储的队长
TeamModel.getTeamMgr().setTeamLeader(teamID, uid)
return
def autoRecoverHpMp():
#ffext.dump('autoRecoverHpMp...')
ffext.getSessionMgr().foreach(recoverHpMp)
ffext.timer(Base.PLAYER_RECOVER_HPMP_MS, autoRecoverHpMp)
return
def sendMsg2OnlineMember(self, cmd, msg):
for key, val in self.getGuildMember().iteritems():
tmpSession = ffext.getSessionMgr().findByUid(val.uid)
if None != tmpSession:
tmpSession.sendMsg(cmd, msg)
def callback(db):
session.user = PlayerModel.User()
session.user.username = msg.username
reconnectUid = msg.reconnectUid
retRole = []
if db.result:
accountId = long(db.result[0][0])
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
ffext.getSessionMgr().foreach_until(funcToClose)
session.user.accountid = accountId
else:
session.user.accountid = idtool.allocUid()
def cbNewUser(retNew):
accountId = long(retNew.result[0][0])
session.user.accountid = accountId
ffext.dump('cbNewUser', retNew, accountId)
# 登录（new）-记录log
LogModel.logLoginData(accountId, 0, '',
LogModel.LoginOpType.LOGIN_ACCOUNT,
LogModel.LoginReason.NEW_LOGIN)
return
DbService.getPlayerService().createUser(msg.username, cbNewUser)
ffext.dump('load player', db.result)
for row in db.result:
roleTmp = PlayerModel.Role(row)
session.user.addRole(roleTmp)
tmpRoleMsg = MsgDef.RoleInfo(roleTmp.uid, roleTmp.name,
roleTmp.job, roleTmp.gender,
roleTmp.level, roleTmp.exp)
retRole.append(tmpRoleMsg)
#print(session.user.accountid, session.user.username)
ffext.checkWebDebug(session, msg, MsgDef)
retMsg = MsgDef.UserInfoRet(ffext.getTime(), retRole)
if reconnectUid: #重连
processSelectRoleReq(session, MsgDef.SelectRoleReq(reconnectUid),
msg.x, msg.y)
else:
session.sendMsg(MsgDef.ServerCmd.USER_INFO, retMsg)
# 登录（old）-记录log-(TODO:ip,geo信息获取接口暂缺)
LogModel.logLoginData(session.user.accountid, 0, '',
LogModel.LoginOpType.LOGIN_ACCOUNT,
LogModel.LoginReason.OLD_LOGIN)
def foreachOnlineMember(self, callback):
for key, val in self.getGuildMember().iteritems():
tmpSession = ffext.getSessionMgr().findByUid(val.uid)
if None != tmpSession and None != tmpSession.player:
callback(tmpSession.player)
def processFriendListOps(session, msg):
friendUid = msg.uid
opstype = msg.opstype
friendSession = ffext.getSessionMgr().findByUid(friendUid)
uid = session.player.uid
#用户申请添加别人为好友的语句
if opstype == MsgDef.FriendOpsClientCmd.INVITE_ADD_LISTFRIEND:
#如果好友不在线，提示用户，好友不在线，不能添加（此处由客户端判断，理论上是有用户面对面才可以添加好友）
if None == friendSession:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'对方不在线，无法添加'))
return
#判断是否已经为好友（此处由客户端判断，已经为好友的不能再次添加）
if None != session.player.friendCtrl.getFriendByUid(friendUid):
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'双方已是好友，无法再次添加'))
return
#判断是否发送过好友申请如未发送，则在对方临时好友列表中添加个人信息
# if None == friendSession.player.friendCtrl.getFriendTempByUid(uid):
# #将用户信息添加至好友的临时好友表中
# friendSession.player.friendCtrl.addFriendTemp(session.player)
#将好友邀请发送给对方客户端
friendSession.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, uid, session.player.name,
session.player.job,
session.player.gender,
session.player.level, True))
return
#用户确认添加别人为好友的语句
if opstype == MsgDef.FriendOpsClientCmd.VERIFY_ADD_LISTFRIEND:
#判断是否在临时好友列表中
# if None == session.player.friendCtrl.getFriendTempByUid(friendUid):
# session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS, '不在待验证好友列表中，无法进行确认'))
# return.
if None == friendSession:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'对方不在线，无法确认添加好友'))
return
#将好友关系写入数据库
DbService.getFriendService().addFriend(uid, friendUid)
session.player.friendCtrl.addFriend(friendSession.player)
session.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, friendUid,
friendSession.player.name,
friendSession.player.job,
friendSession.player.gender,
friendSession.player.level, True))
if None != friendSession:
friendSession.player.friendCtrl.addFriend(session.player)
friendSession.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, uid, session.player.name,
session.player.job,
session.player.gender,
session.player.level, True))
return
#用户拒绝添加别人为好友的语句
if opstype == MsgDef.FriendOpsClientCmd.REFUSE_ADD_LISTFRIEND:
#判断是否在临时好友列表中
# if None == session.player.friendCtrl.getFriendTempByUid(friendUid):
# session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS, '不在待验证好友列表中，无法进行拒绝'))
# return
#忽略好友申请成功，将成功信息反馈给客户端
session.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, friendUid, '', 0, 0, 0, True))
if None != friendSession:
friendSession.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, uid, session.player.name,
session.player.job,
session.player.gender,
session.player.level, True))
return
#用户删除好友的语句
if opstype == MsgDef.FriendOpsClientCmd.DEL_LISTFRIEND:
#判断是否为好友
# if None == session.player.friendCtrl.getFriendByUid(friendUid):
# session.sendMsg(MsgDef.ServerCmd.ERROR_MSG, processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS, '不是好友，无法进行删除'))
# return
#从数据库中将好友关系删除
DbService.getFriendService().delFriend(uid, friendUid)
session.player.friendCtrl.delFriend(friendUid)
session.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, friendUid, '', 0, 0, 0, True))
#数据库操作成功，给用户返回删除好友正常的信息
if None != friendSession:
#如果好友在线，则将好友删除信息反馈给好友
friendSession.player.friendCtrl.delFriend(uid)
friendSession.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, uid, '', 0, 0, 0, True))
return
#将ID加入仇人列表中
#将ID加入仇人列表中
if opstype == MsgDef.FriendOpsClientCmd.ADD_ENEMY:
#如果对方不在线，提示用户，对方不在线，不能添加
if None == friendSession:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'对方不在线，无法添加'))
return
if checkUserEnemy(session, friendUid):
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'对方已在您的仇人列表中'))
return
#将好友关系写入数据库
DbService.getFriendService().addEnemy(uid, friendUid, 0)
session.player.friendCtrl.addEnemy(friendSession.player)
session.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, friendUid,
friendSession.player.name,
friendSession.player.job,
friendSession.player.gender,
friendSession.player.level, True))
return
#将ID从仇人列表中删除
if opstype == MsgDef.FriendOpsClientCmd.DEL_ENEMY:
if not checkUserEnemy(session, friendUid):
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'对方不在您的仇人列表中'))
return
#将好友关系写入数据库
DbService.getFriendService().delEnemy(uid, friendUid, 0)
session.player.friendCtrl.delEnemyByUid(friendUid)
session.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, friendUid, '', 0, 0, 0, True))
return
#将ID加入屏蔽列表中
if opstype == MsgDef.FriendOpsClientCmd.ADD_SHIELD:
#如果对方不在线，提示用户，对方不在线，不能添加
if None == friendSession:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'对方不在线，无法添加'))
return
if checkUserShieldPerson(session, friendUid):
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'对方已在您的屏蔽列表中'))
return
#将好友关系写入数据库
DbService.getFriendService().addEnemy(uid, friendUid, 1)
session.player.friendCtrl.addShieldPerson(friendSession.player)
session.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, friendUid,
friendSession.player.name,
friendSession.player.job,
friendSession.player.gender,
friendSession.player.level, True))
return
#将ID从仇人列表中删除
if opstype == MsgDef.FriendOpsClientCmd.DEL_SHIELD:
if not checkUserShieldPerson(session, friendUid):
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, MsgDef.ClientCmd.FRIENDLIST_OPS,
'对方不在您的屏蔽列表中'))
return
#将好友关系写入数据库
DbService.getFriendService().delEnemy(uid, friendUid, 1)
session.player.friendCtrl.deShieldPersonByUid(friendUid)
session.sendMsg(
MsgDef.ServerCmd.FRIEHND_MSG,
processFriendPlayerMsgRet(opstype, friendUid, '', 0, 0, 0, True))
return
def processChat(session, msg):
ffext.dump('processChat', msg)
uid = msg.uid
#if session.isWebDebug:
# msg.chatMsg = msg.chatMsg.encode('utf-8')
retVal = MsgDef.ChatMsgRet()
ret_msg = retVal
ret_msg.name = session.player.name
ret_msg.uid = session.player.uid
ret_msg.opstype = msg.opstype
ret_msg.chatMsg = msg.chatMsg
if len(msg.chatMsg) > 0 and msg.chatMsg[0] == '@':
msg.opstype = MsgDef.ChatMsgCmd.MapCHAT
#用户一对一聊天
if msg.opstype == MsgDef.ChatMsgCmd.PERSONCHAT:
friendSession = ffext.getSessionMgr().findByUid(msg.uid)
if None != friendSession:
friendSession.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
session.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
ret_msg.chatMsg = '对方不在线!%d' % (msg.uid)
session.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
#用户世界聊天
if msg.opstype == MsgDef.ChatMsgCmd.WORLDCHAT:
session.broadcast(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
#用户组队聊天
if msg.opstype == MsgDef.ChatMsgCmd.TEAMCHAT:
teamID = session.player.teamCtrl.teamID
if 0 == teamID:
ret_msg.chatMsg = '没有参与组队'
session.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
for uid, val in TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(uid)
if None != memberSession:
memberSession.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
#用户行会聊天
if msg.opstype == MsgDef.ChatMsgCmd.GUILDCHAT:
guildInfo = session.player.guildCtrl.guildInfo
if None == guildInfo:
ret_msg.chatMsg = '没有参与组队'
session.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
ret_msg.chatMsg = msg.chatMsg
for uid, val in guildInfo.getGuildMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(uid)
if None != memberSession:
memberSession.sendMsg(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
#系统广播
if msg.opstype == MsgDef.ChatMsgCmd.SYSTEMCHAT:
ret_msg.uid = 0
ret_msg.name = '系统管理员'
session.broadcast(MsgDef.ServerCmd.CHAT_MSG, ret_msg)
return
#用户地图广播
if msg.opstype == MsgDef.ChatMsgCmd.MapCHAT or msg.chatMsg[0] == '@':
data = msg.chatMsg
print(data)
if len(data) > 1 and data[0] == '@': #GM
argsSrc = data.split(' ')
args = []
for k in argsSrc:
if k != '':
args.append(k)
ffext.dump(args)
func = GM2FUNC.get(args[0], None)
if func:
func(session, args)
ffext.dump("chat", retVal)
session.player.broadcast(MsgDef.ServerCmd.CHAT_MSG, retVal)
return
#下面代码注释掉
"""
def processBrotherOps(session, msg): #0表示邀请别人一起结义
opstype = msg.opstype
cmd = MsgDef.ClientCmd.BROTHER_OPS
#ffext.dump('processBrotherrOps', msg)
player = session.player
uid = player.uid
uid1 = msg.uid1
uid2 = msg.uid2
if opstype == MsgDef.BrotherClientCmd.INVITE_ADD_BROTHER:
#获取用户邀请结义的ID
player2 = player.mapObj.getPlayerById(uid1)
player3 = player.mapObj.getPlayerById(uid2)
if False == checkPlayerCanBeBro(opstype, player, player2, player3):
return False
brotherInfo = TeamModel.BrotherCtrl()
brotherInfo.addBrotherMember(player, player2, player3)
player.brotherCtrl.tmpBrotherInfo = brotherInfo
player2.brotherCtrl.tmpBrotherInfo = brotherInfo
player3.brotherCtrl.tmpBrotherInfo = brotherInfo
#将邀请信息发给对方
allBrotherInfo = []
allBrotherInfo.append(processBrotherOpsMsg(player, True))
allBrotherInfo.append(processBrotherOpsMsg(player2, True))
allBrotherInfo.append(processBrotherOpsMsg(player3, True))
session.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, allBrotherInfo, True, 0))
player2.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, allBrotherInfo, True, 0))
player3.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, allBrotherInfo, True, 0))
brotherInfo.getMemberInfo(
player.uid
).status = TeamModel.BrotherStatus.BRO_VERIFY_INVIT #自动确认
return
if msg.opstype == MsgDef.BrotherClientCmd.VERIFY_INVIT_ADD_BROTHER:
brotherInfo = player.brotherCtrl.tmpBrotherInfo
if not brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '结义状态已经解除。'))
return
playerList = brotherInfo.getPlayers()
player1 = playerList[0]
player2 = playerList[1]
player3 = playerList[2]
if False == checkPlayerCanBeBro(opstype, player1, player2, player3):
return False
brotherInfo.getMemberInfo(
player.uid).status = TeamModel.BrotherStatus.BRO_VERIFY_INVIT
player1.sendMsg(MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], True, 0))
player2.sendMsg(MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], True, 0))
player3.sendMsg(MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], True, 0))
return
if msg.opstype == MsgDef.BrotherClientCmd.REFUSE_INVITT_ADD_BROTHER:
brotherInfo = player.brotherCtrl.tmpBrotherInfo
if not brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '结义状态已经解除。'))
return
playerList = brotherInfo.getPlayers()
for k in playerList:
if k:
k.brotherCtrl.tmpBrotherInfo = None
k.sendMsg(MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], True, 0))
return
#用户确认结义
if msg.opstype == MsgDef.BrotherClientCmd.CONFIRM_INVIT_ADD_BROTHER:
brotherInfo = player.brotherCtrl.tmpBrotherInfo
if not brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '结义状态已经解除。'))
return
playerList = brotherInfo.getPlayers()
player1 = playerList[0]
player2 = playerList[1]
player3 = playerList[2]
brotherInfo.getMemberInfo(
player.uid).status = TeamModel.BrotherStatus.BRO_CONFIRM
player1.sendMsg(MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], True, 0))
player2.sendMsg(MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], True, 0))
player3.sendMsg(MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], True, 0))
allConfirm = True
for k in playerList:
if k == None or brotherInfo.getMemberInfo(
k.uid).status != TeamModel.BrotherStatus.BRO_CONFIRM:
allConfirm = False
break
if allConfirm:
bid = TeamModel.getBrotherMgr().addBrotherInfo(brotherInfo)
player1.brotherCtrl.tmpBrotherInfo = None
player2.brotherCtrl.tmpBrotherInfo = None
player3.brotherCtrl.tmpBrotherInfo = None
player1.brotherCtrl.brotherInfo = brotherInfo
player2.brotherCtrl.brotherInfo = brotherInfo
player3.brotherCtrl.brotherInfo = brotherInfo
sendBroList(player1.session)
sendBroList(player2.session)
sendBroList(player3.session)
return
#用户强制退出结义
if opstype == MsgDef.BrotherClientCmd.QUIT_BROTHER:
#先判断用户是否有结义
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户没有结义信息。'))
return
if session.player.gold < TeamModel.BROTHER_QUIT_GOLD:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '金钱不足，不能强制退出。'))
return
#扣除金钱
session.player.addGold(-1 * TeamModel.BROTHER_QUIT_GOLD)
bid = brotherInfo.bid
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
memberSession.player.skillCtrl.deleteSkill(Base.BRO_SKILL_ID, True)
SkillHandler.processQuerySkill(memberSession)
if None != memberSession:
memberSession.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True,
0))
memberSession.player.brotherCtrl.delBrother(
memberSession.player)
if val.uid == session.player.uid:
continue
else:
memberSession.player.addGold(
int(TeamModel.BROTHER_QUIT_GOLD / 2))
else:
DbService.getPlayerService().updateGold(
val, int(TeamModel.BROTHER_QUIT_GOLD / 2))
TeamModel.getBrotherMgr().delBrother(bid)
return
#发送结义列表
if opstype == MsgDef.BrotherClientCmd.GET_BROTHERLIST:
sendBroList(session, opstype)
return
#用户协商退出结义（必须三个人同时在线）
if opstype == MsgDef.BrotherClientCmd.CONSULT_QUIT_BROTHER:
#先判断用户是否有结义
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户没有结义信息。'))
return
#判断三个人是否同时在线
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if None == memberSession:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户协议取消结义时，必须同时在线！'))
return
brotherInfo.getMemberInfo(
player.uid).status = TeamModel.BrotherStatus.BRO_QUIT
allQuit = True
for key, val in brotherInfo.getBrotherMember().iteritems():
if val.status != TeamModel.BrotherStatus.BRO_QUIT:
allQuit = False
break
delTime = 0
delTimeSec = 1
if allQuit:
delTime = ffext.getTime() + delTimeSec
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
memberSession.player.skillCtrl.deleteSkill(Base.BRO_SKILL_ID, True)
SkillHandler.processQuerySkill(memberSession)
memberSession.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], False, delTime))
if allQuit:
def cb():
processBrotherDel(session, opstype)
return
ffext.timer(delTimeSec * 1000, cb)
return
#用户取消退出结义
if opstype == MsgDef.BrotherClientCmd.CANCLE_QUIT_BROTHER:
#先判断用户是否有结义
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户没有结义信息。'))
return
if brotherInfo.getMemberInfo(
player.uid).status != TeamModel.BrotherStatus.BRO_QUIT:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '不需要取消。'))
return
brotherInfo.getMemberInfo(
player.uid).status = TeamModel.BrotherStatus.BRO_OK
for key, val in brotherInfo.getBrotherMember().iteritems():
memberSession = ffext.getSessionMgr().findByUid(val.uid)
if None != memberSession:
memberSession.sendMsg(
MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, session.player, [], True,
0))
return
elif opstype == MsgDef.BrotherClientCmd.LEARN_BRO_SKILL: #9学习结义技能
brotherInfo = session.player.brotherCtrl.brotherInfo
if None == brotherInfo:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '用户没有结义信息。'))
return
skillLevel = 1
retErr = player.skillCtrl.learnSkill(Base.BRO_SKILL_ID, skillLevel) #
if retErr:
session.sendMsg(
MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(
opstype, cmd,
'学习技能%d失败，原因:%s!' % (Base.BRO_SKILL_ID, retErr)))
return
session.sendMsg(MsgDef.ServerCmd.LEARN_SKILL,
MsgDef.LearnSkillRet(Base.BRO_SKILL_ID, skillLevel))
session.sendMsg(MsgDef.ServerCmd.BROTHER_OPS_MSG,
processBrotherOpsMsgRet(opstype, player, [], False, 0))
def processMarryOpsMsgRet(opstype,
player,
flag=0,
delTime=0,
msg='',
gold=0,
skillId=0,
marryTotalInfo=None):
ret_msg = MsgDef.MarriageOpsMsgRet(opstype, MsgDef.MarriageBaseInfo())
ret_msg.opstype = opstype
if not marryTotalInfo:
if player and player.marriageCtrl.marryTotalInfo:
marryTotalInfo = player.marriageCtrl.marryTotalInfo
if marryTotalInfo:
ret_msg.delTime = marryTotalInfo.tmEndWedding
#ffext.dump('self.listSetItems', marryTotalInfo.listSetItems)
ret_msg.baseInfo.marryId = marryTotalInfo.marryId
ret_msg.baseInfo.flagXiTie = marryTotalInfo.flagXiTie
ret_msg.baseInfo.flagWeding = marryTotalInfo.flagWeding
ret_msg.baseInfo.tmWedding = marryTotalInfo.tmWedding
ret_msg.baseInfo.coupleData = []
ret_msg.baseInfo.listAttends = []
for k in marryTotalInfo.coupleData:
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
tmpmsg.online = False
if ffext.getSessionMgr().findByUid(k.uid):
tmpmsg.online = True
ret_msg.baseInfo.coupleData.append(tmpmsg)
for k in marryTotalInfo.listAttends:
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
tmpmsg.online = False
if ffext.getSessionMgr().findByUid(k.uid):
tmpmsg.online = True
ret_msg.baseInfo.listAttends.append(tmpmsg)
ret_msg.setupItems = []
for k, v in marryTotalInfo.listSetItems.iteritems():
#ret_msg.setupItems.append(v)
ret_msg.setupItems.append(
MsgDef.MarriageItem(k, v.get('itemCfgId', 0)))
#ret_msg.allMarriageInfo = allMarriageInfo
ret_msg.flag = flag
if delTime != 0:
ret_msg.delTime = delTime
ret_msg.msg = msg
ret_msg.gold = gold
ret_msg.getItems = []
#ret_msg.setupItems = []
ret_msg.weddingSkillId = skillId
ret_msg.listVisitHouseInfo = []
#ret_msg.otherHouseInfo = {}
return ret_msg
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
