def create_master(self):
"""
创建Master服务
:return:
"""
config = Config().config
GlobalObject().json_config = config
mastercnf = config.get('master')
rootport = mastercnf.get('rootport')
webport = mastercnf.get('webport')
masterlog = mastercnf.get('log')
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
self.web = vhost.NameVirtualHost()
self.web.addHost('0.0.0.0', './')
GlobalObject().root = self.root
GlobalObject().webroot = self.web
import webapp
import rootapp
internet.TCPServer(webport, DelaySite(self.web)).setServiceParent(self.service)
internet.TCPServer(rootport, BilateralFactory(self.root)).setServiceParent(self.service)
self.process.setServiceParent(self.service)
def execute(self, *args, **kwargs):
"""
用户准备/取消准备
:param args:
:param kwargs:
:return:
"""
validator = UserReadyValidator(handler=self)
if 1 == validator.ready.data:
validator.user.set_status(UserStatus.READY)
else:
validator.user.set_status(UserStatus.UNREADY)
data = {
"user_id": validator.user.user_id,
"nick": validator.user.nick_name,
"ready": validator.ready.data,
"seat_id": validator.user.seat_id
}
validator.desk.notify_desk_some_user(PUSH_USER_READY, data,
[validator.user.user_id])
response_data = {"ready": validator.ready.data}
validator.desk.notify_player(validator.user.seat_id, USER_READY,
response_data)
# 当所有玩家都准备好时，默认触发游戏开始
all_ready = 1
for u in validator.desk.users:
if not u or u.status == UserStatus.UNREADY:
all_ready = 0
break
if all_ready:
# 通知web服务器记录是否开始
user_ids = []
for i in validator.desk.users:
user_ids.append(i.user_id)
ret = notify_web_server_match_room_start_game(
user_ids,
validator.session_id.data,
room_name=GlobalObject().json_config.get("name", ''),
room_type=validator.desk.room_type)
if ret.get("ret") == 0:
validator.desk.start_game()
else:
raise Exception("start game error ret=%s" % ret)
return {"need_push": 0}
def render(self, request):
username = request.args['username'][0]
oprea_str = request.args['opera_str'][0]
# register_admin，注册表的mmode管理器，getObjData(username)，通过主键获取的对应的数据，dict型
usermodedata = register_admin.getObjData(username)
if not usermodedata:
return "Account does not exist!!!" # 账号不存在
pid = usermodedata.get('characterId') #角色id
if not pid:
return "Role does not exist!!!" #角色不存在，创建了账号没有创建人物
gate_node = GlobalObject().remote.get('gate')
# method *args **kw
gate_node.callRemote("opera_player", pid,
oprea_str) # 远程调用gate节点中的接口方法
return "Success"
def inner_recvall_0(conn, request):
# logger.debug('django request:%s', request)
conn_details = dict(
id=conn.transport.sessionno,
ip=conn.transport.client[0],
port=conn.transport.client[1],
)
request = eval(request)
cmd = request.get('cmd', None)
if isinstance(cmd, dict):
if cmd['send_cmd'] == proto.CMD_REG:
connid = request['data']['connid']
data = safe_str(request['data']['data'])
for uin in cmd['uin_list']:
# 绑定UIN和CONN关系
GlobalObject().remote['_transfer_'].callRemote(
'bind_id_and_conn', uin, connid)
# 发给用户登录
# logger.debug('send_cmd:%d, data:%s, connid:%d', cmd['send_cmd'], data, connid)
GlobalObject().server.ws.pushObject(cmd['send_cmd'], data,
[connid])
else:
request = safe_str(request.get('data', None))
if request:
if cmd['op_cmd'] == proto.CMD_EVENT_USER_BROADCAST:
GlobalObject().remote['_transfer_'].callRemote(
'write_to_gateway', cmd['send_cmd'], request,
'broadcast_to_all')
elif cmd['op_cmd'] == proto.CMD_WEB_SEND_MSG_TO_USER:
GlobalObject().remote['_transfer_'].callRemote(
'write_to_gateway', cmd['send_cmd'], request,
cmd['uin_list'])
else:
request = dict(body=safe_str(request.get('data', None)), inner=True)
GlobalObject().remote['_transfer_'].callRemote('transfer_to_game', cmd,
request, conn_details)
def try_transfer(self, user_id, request):
"""自动转让盟主(内部接口)"""
timer = Timer(user_id)
req = internal_pb2.TryTransferUnionLeaderReq()
req.ParseFromString(request)
union_req = internal_union_pb2.InternalTryTransferUnionLeaderReq()
union_req.user_id = user_id
defer = GlobalObject().remote['gunion'].callRemote(
"try_transfer_leader", req.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_transfer, req, timer)
defer.addErrback(self._transfer_failed, req, timer)
return defer
def _add_chest_broadcast(self, data, gold):
(mode_id, priority, life_time, content) = chest_business.create_broadcast(
data, gold)
req = broadcast_pb2.AddBroadcastInfoReq()
req.user_id = data.id
req.mode_id = mode_id
req.priority = priority
req.life_time = life_time
req.content = content
request = req.SerializeToString()
logger.debug("Add chest broadcast[req=%s]" % req)
defer = GlobalObject().remote["common"].callRemote("add_broadcast_record", 1, request)
defer.addCallback(self._check_add_chest_broadcast_result)
return defer
def _calc_launch(self, data, req, timer, force):
if not force:
union = data.union.get(True)
if not union.is_belong_to_target_union(req.union_id):
res = union_battle_pb2.QueryUnionBattleRes()
res.status = 0
res.ret = union_pb2.UNION_NOT_MATCHED
defer = DataBase().commit(data)
defer.addCallback(self._launch_succeed, req, res, timer)
return defer
#发起战争
union_req = internal_union_pb2.InternalQueryUnionBattleReq()
union_req.user_id = data.id
if not force:
defer = GlobalObject().remote['gunion'].callRemote(
"launch_battle", req.union_id, union_req.SerializeToString())
else:
defer = GlobalObject().remote['gunion'].callRemote(
"launch_battle_force", req.union_id,
union_req.SerializeToString())
defer.addCallback(self._calc_launch_result, data, req, timer)
return defer
def getOtherPlayerInfo(dynamicId, pid, tid, request_proto):
'''获取其他角色的信息
'''
tvplayer = VCharacterManager().getVCharacterByCharacterId(tid)
if tvplayer:
nownode = 201000 #tvplayer.getNode()
else:
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer:
return
else:
nownode = 201000 #vplayer.getNode()
d = GlobalObject().root.callChild("scense_1000", 221, dynamicId,
request_proto)
return d
def masterapp(self):
"""
"""
config = json.load(open(self.configpath, "r"))
GlobalObject().json_config = config
mastercnf = config.get("master")
rootport = mastercnf.get("rootport")
webport = mastercnf.get("webport")
masterlog = mastercnf.get("log")
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
self.webroot = vhost.NameVirtualHost()
self.webroot.addHost("0.0.0.0", "./")
GlobalObject().root = self.root
GlobalObject().webroot = self.webroot
if masterlog:
log.addObserver(loogoo(masterlog)) # 日志处理
log.startLogging(sys.stdout)
from . import webapp
from . import rootapp
reactor.listenTCP(webport, DelaySite(self.webroot))
reactor.listenTCP(rootport, BilateralFactory(self.root))
def get_leader(data):
"""获取盟主"""
member_list = data.member_list.get_all(True)
for member in member_list:
if member.position == UnionMemberInfo.POSITION_LEADER:
leader = member
break
app_req = internal_pb2.GetUserBasicInfoReq()
app_req.user_id = leader.user_id
defer = GlobalObject().remote['app'].callRemote("get_user_basic_info",
leader.user_id, app_req.SerializeToString())
defer.addCallback(_get_leader_info, leader)
return defer
def masterapp(self):
"""
"""
config = json.load(open(self.configpath, 'r'))
GlobalObject().json_config = config
mastercnf = config.get('master') # master
rootport = mastercnf.get('rootport')
webport = mastercnf.get('webport')
masterlog = mastercnf.get('log')
self.root = PBRoot()
rootservice = services.Service("rootservice")
self.root.addServiceChannel(rootservice)
self.webroot = vhost.NameVirtualHost()
self.webroot.addHost('0.0.0.0', './')
GlobalObject().root = self.root
GlobalObject().webroot = self.webroot
if masterlog:
log.addObserver(loogoo(masterlog)) #日志处理
log.startLogging(sys.stdout)
import webapp
import rootapp
reactor.listenTCP(webport, DelaySite(self.webroot)) # webport开始监听
reactor.listenTCP(rootport,
BilateralFactory(self.root)) # rootport开始监听
def Transfer1501(resultdata, nownode, dynamicId, characterId, instanceId,
famId):
'''调用进入副本方法
@param nownode: int 副本服务器动态id+30W
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
player, placeId = resultdata
#加入角色的实例到创建的副本中去
d = GlobalObject().root.callChild("scense_1000", 1501, player, dynamicId,
characterId, instanceId, famId)
#写入出错时的错误处理
d.addErrback(InFamErrbck, vplayer, nownode, famId)
#写入成功时,清除原先场景中的角色实例
d.addCallback(DropCharacterInSceneForFam, vplayer, nownode, dynamicId,
famId)
return d
def DropCharacterInScene(deferResult, vcharacter, nownode, dynamicId):
'''删除原先场景中角色的实例
'''
if not deferResult.get('result', False): #如果不能进行跳转
vcharacter.release() #释放角色对象锁
d = defer.Deferred()
d.callback(deferResult)
else:
# oldnode = vcharacter.getNode()
d = GlobalObject().root.callChild("scense_1000", 612, dynamicId,
vcharacter.characterId)
# d = root.callChild(oldnode,612,dynamicId, vcharacter.characterId)
d.addErrback(sceneErorrBack2, nownode, dynamicId, vcharacter)
d.addCallback(cleanOldScene, deferResult, vcharacter, dynamicId,
nownode)
return d
def enterScene(dynamicId, characterId, placeId, force):
'''进入场景
@param dynamicId: int 客户端的ID
@param characterId: int 角色的ID
@param placeId: int 场景的ID
@param force: bool
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer:
return None
nownode = SceneSerManager().getBsetScenNodeId()
d = GlobalObject().root.callChild(nownode, 601, dynamicId, characterId,
placeId, force, None)
vplayer.setNode(nownode)
SceneSerManager().addClient(nownode, vplayer.dynamicId)
return d
def forwarding(key, dynamicId, data):
"""
"""
if localservice._targets.has_key(key):
return localservice.callTarget(key, dynamicId, data)
else:
user = UsersManager().getUserByDynamicId(dynamicId)
if not user:
return
oldvcharacter = VCharacterManager().getVCharacterByClientId(dynamicId)
if not oldvcharacter:
return
if oldvcharacter.getLocked(): #判断角色对象是否被锁定
return
node = VCharacterManager().getNodeByClientId(dynamicId)
return GlobalObject().root.callChild(node, key, dynamicId, data)
def _accept(self, data, member, application, req, timer):
"""接受玩家申请
"""
union = data.union.get()
app_req = internal_union_pb2.InternalUnionOperateReq()
app_req.operator_user_id = member.user_id
app_req.union_name = union.get_readable_name()
app_req.union_id = union.id
app_req.time = application.time
defer = GlobalObject().remote['app'].callRemote(
"been_accept_by_union", application.user_id,
app_req.SerializeToString())
defer.addCallback(self._post_accept, data, application, req, timer)
return defer
def _manage_notice(self, user_id, content):
"""操作通知
"""
forward_req = internal_pb2.ReceiveMailReq()
forward_req.user_id = user_id
forward_req.mail.basic_id = 100
forward_req.mail.subject = data_loader.ServerDescKeyInfo_dict[
"union_notice"].value.encode("utf-8")
forward_req.mail.content = content
forward_req.mail.sender = data_loader.ServerDescKeyInfo_dict[
"union_sender"].value.encode("utf-8")
defer = GlobalObject().remote['app'].callRemote(
"receive_mail", user_id, forward_req.SerializeToString())
defer.addCallback(self._post_notice)
return defer
def JoinDuiWu(dynamicId,pid,pos,dwId):
'''加入队伍
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer or vplayer.getLocked():#判断是否存在角色或者角色是否被锁定
return
# nownode = vplayer.getNode()
d = GlobalObject().root.callChild("scense_1000",610,dynamicId, pid)
d.addErrback(ErorrBack)
d.addCallback(TransferPlayerJoin,dynamicId,pid,pos,dwId)
return d
def pushmsg(message_id, msg, send_list):
if not isinstance(msg, str):
if isinstance(msg, dict) or isinstance(msg, list):
msg = json.dumps(msg)
else:
msg = str(msg)
# print "pushmg:::::::::::::::::::", message_id, msg, send_list
if 0 >= len(send_list):
return
server_name = set(p[0] for p in send_list)
for s in server_name:
session_uids = []
for p in send_list:
if s == p[0]:
session_uids.append(p[1])
GlobalObject().root.callChildByName(s, "push_object", message_id, msg, session_uids)
def notify_quit_list(self, notify_list, cid):
#print "notify_quit_list %s,%s"%(notify_list,cid);
if len(notify_list) <= 0:
return
dId_list = []
for i in notify_list:
dId = self._getdidbycid(i)
if dId != None:
dId_list.append(dId)
#print "%s"%(dId_list);
data = {}
data['id'] = cid
buf = netutil.s2c_data2bufbycmd(S2C_MAP_DEL, data)
GlobalObject().remote['gate'].callRemote("pushObject", S2C_MAP_DEL,
buf, dId_list)
return
def _calc_start(self, data, req, timer):
union = data.union.get(True)
if not union.is_belong_to_target_union(req.union_id):
#玩家不属于联盟
res = union_battle_pb2.StartUnionBattleRes()
res.status = 0
res.ret = union_pb2.UNION_NOT_MATCHED
defer = DataBase().commit(data)
defer.addCallback(self._start_succeed, req, res, timer)
return defer
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
#参战队伍 & 英雄
teams = []
heroes = []
for team_info in req.battle.attack_teams:
team_id = TeamInfo.generate_id(data.id, team_info.index)
team = data.team_list.get(team_id)
if team is None:
continue
teams.append(team)
for hero_id in team.get_heroes():
if hero_id != 0:
hero = data.hero_list.get(hero_id)
heroes.append(hero)
#检查是否可以开战
if not union_battle_business.is_able_to_start_battle(
data, teams, heroes, timer.now, req.cost_gold):
raise Exception("Not able to start battle")
#开战，请求本方联盟核实信息
user = data.user.get(True)
union_req = internal_union_pb2.InternalStartUnionBattleReq()
union_req.is_attack_side = True
union_req.attacker_user_id = data.id
defer = GlobalObject().remote['gunion'].callRemote(
"start_battle", req.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_start_result, data, teams, heroes, req,
timer)
return defer
def _calc_query(self, data, req, timer):
union = data.union.get(True)
if not union.is_belong_to_target_union(req.union_id):
res = union_pb2.QueryUnionAidRes()
res.status = 0
res.ret = union_pb2.UNION_NOT_MATCHED
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
union_req = internal_union_pb2.InternalQueryUnionAidReq()
union_req.user_id = data.id
defer = GlobalObject().remote['gunion'].callRemote(
"query_aid", req.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_query_result, data, req, timer)
return defer
def notify_enter_new_region(self, cid, x, y, rw, rh):
#print "notify_enter_new_region %s,%s,%s,%s,%s"%(cid,x,y,rw,rh);
dId = self._getdidbycid(cid)
if dId == None:
print "notify_region_2_c fatal error %d" % (cid)
return
data = {}
data['rw'] = rw
data['rh'] = rh
data['x'] = x
data['y'] = y
buf = netutil.s2c_data2bufbycmd(S2C_MAP_REGIONCHANGE, data)
GlobalObject().remote['gate'].callRemote("pushObject",
S2C_MAP_REGIONCHANGE, buf,
[dId])
return
def _calc_receive_deploy_force(self, data, req, timer):
union = data.union.get(True)
if not union.is_belong_to_target_union(req.union_id):
#玩家不属于联盟
res = union_battle_pb2.DeployUnionBattleForceRes()
res.status = 0
res.ret = union_pb2.UNION_NOT_MATCHED
defer = DataBase().commit(data)
defer.addCallback(self._receive_deploy_succeed, req, res, timer)
return defer
battle_score = data.battle_score.get()
teams_index = battle_score.get_powerful_teams_id()[0:3] #取前三队
teams = []
for team_index in teams_index:
team_id = TeamInfo.generate_id(data.id, team_index)
team = data.team_list.get(team_id, True)
teams.append(team)
if not union_battle_business.is_able_to_deploy(data, req.node_index,
teams, True):
raise Exception("Team deploy invalid")
union_req = internal_union_pb2.InternalDeployUnionBattleReq()
user = data.user.get(True)
union_req.user_id = data.id
union_req.defender_user_id = data.id
union_req.defender_user_name = user.get_readable_name()
union_req.defender_user_icon = user.icon_id
union_req.defender_user_level = user.level
union_req.node_index = req.node_index
for team in teams:
team_msg = union_req.teams.add()
team_msg.index = team.index
for hero_id in team.get_heroes():
if hero_id != 0:
hero = data.hero_list.get(hero_id, True)
pack.pack_hero_info(hero, team_msg.heroes.add(), timer.now)
for tech in data.technology_list.get_all(True):
if tech.is_battle_technology() and not tech.is_upgrade:
union_req.battle_tech_ids.append(tech.basic_id)
defer = GlobalObject().remote['gunion'].callRemote(
"deploy_battle", req.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_receive_deploy_result, data, req, timer)
return defer
def add_reputation(self, user_id, request):
"""添加声望，内部接口
"""
timer = Timer(user_id)
req = internal_pb2.AddReputationReq()
req.ParseFromString(request)
unit_req = unit_pb2.UnitAddReputationReq()
unit_req.user_id = user_id
unit_req.reputation = req.reputation
#请求 Unit 模块
defer = GlobalObject().remote['unit'].callRemote(
"add_reputation", req.city_id, unit_req.SerializeToString())
defer.addCallback(self._add_reputation_succeed, req, timer)
defer.addErrback(self._add_reputation_failed, req, timer)
return defer
def _calc_query_rival(self, data, req, timer):
"""请求 unit 模块，核实对手信息
"""
city_id = LegendCityInfo.generate_id(data.id, req.rival.city_id)
legendcity = data.legendcity_list.get(city_id)
unit_req = unit_pb2.UnitCheckLegendCityReq()
unit_req.user_id = data.id
unit_req.rival_id = req.rival.user.user_id
unit_req.rival_position_level = req.rival.level
#查询官职信息
defer = GlobalObject().remote['unit'].callRemote(
"check", legendcity.city_id, unit_req.SerializeToString())
defer.addCallback(self._query_rival_detail, data, req, timer)
defer.addCallback(self._query_rival_succeed, data, req, timer)
return defer
def doWhenStop(self):
'''when netserver stoped'''
# from bridge.famsermanger import FamSerManager
# from bridge.scenesermanger import SceneSerManager
# from core.UserManager import UsersManager
from app.gate.core.VCharacterManager import VCharacterManager
# from app.gate.serverconfig.root import root
# childs = root._childsmanager._childs.keys()
# for node in childs:
# if 200000<node<300000:
# root.callChild(node,50)
for vcharacter in VCharacterManager().character_client.values():
dynamicId = vcharacter.dynamicId
node = vcharacter.getNode()
if node:
# root.callChild(node,2,dynamicId)
GlobalObject().root.callChild("scense_1000", 2, dynamicId)
def enterScene(dynamicId, characterId, placeId, force):
'''进入场景
@param dynamicId: int 客户端的ID
@param characterId: int 角色的ID
@param placeId: int 场景的ID
@param force: bool
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer:
return None
nownode = SceneSerManager().getBestScenNodeId() # 获取最佳的game服务器
# 调用子节点 childname, *args
d = GlobalObject().root.callChild(nownode, 601, dynamicId, characterId,
placeId, force, None)
vplayer.setNode(nownode) # 设置节点服务器
SceneSerManager().addClient(nownode, vplayer.dynamicId) # 添加到场景服务器
return d
def _calc_query(self, data, req, timer):
res = union_boss_pb2.QueryUnionBossRes()
res.status = 0
union = data.union.get(True)
if union is None or not union.is_belong_to_target_union(req.union_id):
res.ret = union_pb2.UNION_NOT_MATCHED
return self._query_succeed(data, req, res, timer)
union_req = internal_union_pb2.InternalQueryUnionBossReq()
union_req.user_id = data.id
union = data.union.get(True)
defer = GlobalObject().remote['gunion'].callRemote(
"query_unionboss", union.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_query_result, data, req, res, timer)
return defer
def handmsg(cmdid, session, data):
remotename = msgdefault
if msgrule:
for k in msgrule:
if cmdid in msgrule[k]:
remotename = k
break
sessionid = session.getsession()
begintm = time.clock()
msg = yield GlobalObject().remote[remotename].callRemote(
"handlegamemsg", sessionid, cmdid, data)
endtm = time.clock()
calltm = endtm - begintm
log.msg("%s rpclog: %s %s %s %s %s %s %s" %
(servername, sessionid, begintm, endtm, calltm, cmdid, data, msg))
defer.returnValue(msg)
