def processCheckMacTeamNum(session, memberSession, opstype, cmd):
if session.player.uid == session.player.teamCtrl.teamID and TeamModel.getTeamMgr(
).getTeamById(session.player.teamCtrl.teamID).getLenTeamMember(
) >= TeamModel.MAX_TEAM_NUM:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '您的队伍已满，不能再加入队员'))
return False
if memberSession.player.uid == memberSession.player.teamCtrl.teamID and TeamModel.getTeamMgr(
).getTeamById(memberSession.player.teamCtrl.teamID).getLenTeamMember(
) >= TeamModel.MAX_TEAM_NUM:
session.sendMsg(MsgDef.ServerCmd.ERROR_MSG,
processErrorMsgRet(opstype, cmd, '对方的队伍已满，不能再加入队员'))
return False
return True
def get(self) -> Response:
teams = TeamModel.get_all_teams()
result = [{
'name':
team.team_name,
'member':
[user.name for user in UserModel.get_users_by_team(team)],
} for team in teams]
return jsonify(result)
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 processTeamList(session, msg):
opstype = msg.opstype
ret_msg = MsgDef.TeamListMsgRet()
ret_msg.allTeamInfo = []
ret_msg.opstype = opstype
teamID = session.player.teamCtrl.teamID
#获取队伍成员信息
if opstype == MsgDef.TeamListClientCmd.GET_TEAMLIST:
if 0 != teamID:
#遍历allFriend字典，获取好友属性
for uid, val in TeamModel.getTeamMgr().getTeamById(
teamID).getTeamMember().iteritems():
if teamID == val.uid:
leader = True
else:
leader = False
ret_msg.allTeamInfo.append(
processTeamPlayerMsg(val.uid, val.name, val.job,
val.gender, val.level, val.hp,
val.hpMax, val.mp, val.mpMax,
val.anger, val.angerMax, leader))
session.sendMsg(MsgDef.ServerCmd.TEAMLIST_MSG, ret_msg)
return
def __init__(self, dbRow=None):
Player.NUM += 1
ffext.dump('Player new', Player.NUM)
#各个模块增加的属性
self.allPropByModule = {}
self.mapObj = None
self.session = None
self.last_move_tm = time.time()
self.friendCtrl = FriendModel.FriendCtrl()
self.teamCtrl = TeamModel.PersonTeamCtrl(self)
self.guildCtrl = GuildModel.PersonGuildCtrl(self)
self.skillCtrl = SkillModel.SkillCtrl(self)
self.taskCtrl = TaskModel.TaskCtrl(self)
self.itemCtrl = ItemModel.ItemCtrl(self)
self.buffCtrl = MonsterModel.BuffCtrl(self)
self.petCtrl = PetModel.PetCtrl(self)
self.brotherCtrl = TeamModel.PersonBrotherCtrl()
self.mailCtrl = MailModel.MailCtrl(self)
self.loginActCtrl = LoginRewardModel.LoginActCtrl(self)
#竞技场相关的
self.arenaCtrl = ArenaCtrl()
self.marriageCtrl = MarryModel.PersonMarryCtrl(self)
self.moneyBankCtrl = MoneyBankCtrl()
self.tmpInfo = {} #临时数据
self.uid = 0
self.name = ''
self.job = 0
self.gender = 0
self.gold = 0
self.mapname = ''
self.x = 0
self.y = 0
self.level = 1
self.exp = 0
self.direction = 0
#self.powerFight = 0#战斗力 实时计算
self.hp = 0
self.mp = 0
self.hpMax = 0
self.mpMax = 0
self.physicAttackMin = 0 #最小物理攻击
self.physicAttackMax = 0 #最大物理攻击
#法术攻击
self.magicAttackMin = 0 #最小法术攻击
self.magicAttackMax = 0 #最大法术攻击
#物理防御
self.physicDefendMin = 0 #最小物理防御
self.physicDefendMax = 0 #最大物理防御
#法术防御
self.magicDefendMin = 0 #最小法术防御
self.magicDefendMax = 0 #最大法术防御
#暴击
self.crit = 0 #暴击 影响暴击的概率 浮点数
self.hit = 0 #命中 影响攻击时的命中率 浮点数
self.avoid = 0 #躲避 被攻击时，影响降低被命中的概率 浮点数
self.attackSpeed = 0 #攻击速度
self.attackSing = 0 #攻击吟唱时间 影响释放攻击动作前的吟唱时间 吟唱时间内被攻击，有50%概率被打断，打断后需要重新吟唱，单位：秒 精确到毫秒
self.attackInterval = 0 #两次攻击之间间隔时间，单位：秒 精确到毫秒
self.attackDistance = 0 #攻击距离 以单位为中心的圆内可以攻击，近战标准值：100，远程值：600
self.moveSpeed = 0 #移动速度 影响地图上移动速度，标准值：100 精确到毫秒
self.hurtAbsorb = 0 #伤害吸收 受到伤害时，一定比例转换为生命值 百分比
self.hpAbsorb = 0 #吸血 当对敌人造成伤害时，吸取血量恢复自身生命值 百分比
self.pkSinValue = 0 #pk 罪恶值 即杀人数量 白：无杀人记录 橙：杀一个人后在线时间12小时内显示，被人杀死后0.1%掉落身上任一装备 红色：在线时间12小时内杀2个人以上，被人杀死后1%掉落身上任一装备
self.modeAttack = 0 #攻击模式
self.hurtAbsorbLimit = 0 #伤害吸收量
#战斗力
self.fightPower = 0
self.sumAngerTmp = 0 #技能累计怒气是小数
self.anger = 0 #怒气
self.angerMax = Base.MAX_ANGER
#名字颜色
self.nameColor = 0
#NPC相关的
self.npcInfo = NpcInfo()
#用于回调的函数容器
self.callbackFuncs = {}
#记录当前切磋的目标玩家
self.ctrlQieCuo = QieCuoCtrl(self)
self.last_logout = 0 #登出时间
#在线时间
self.logintime = ffext.getTime() #不存DB
self.gametime = 0 #离线时计算，并存DB
#状态机
self.fsm = None #MonsterAI.FSM(self)
#if dbRow:
self.assignFromDB(dbRow)
#安全密码验证状态
self.isVerified = False
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 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 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 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 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))