def StartEventTick(self):
self.StopEventTick()
if util.IsRobot(self.m_nEventOptPlayer) is True:
self.m_nEventTick = tick_mgr.RegisterOnceTick(
4 * 1000, self.NextTurn)
elif self.IsTuoGuan(self.m_nEventOptPlayer) is True:
self.m_nEventTick = tick_mgr.RegisterOnceTick(
1 * 1000, self.NextTurn)
else:
self.m_nEventTick = tick_mgr.RegisterOnceTick(
int(self.GetEventExpireTime() * 1000), self.NextTurn)
def TouchEventMoPai(self, mjMgr, listData):
nPos, nCard = listData
roomObj = mjMgr.GetRoomObj()
nOptMember = roomObj.GetMemberIDByPos(nPos)
nCardType = check_hu_mgr.GetCardType(nCard)
if nCardType == ECardType.eHuaPai:
return
# 摸到这张牌是不是能胡牌
listCard = mjMgr.GetPosCardList(nPos)
assert ((len(listCard) - 2) % 3 == 0)
listJinPai = mjMgr.GetJinPaiList()
import time
nTimeCheckPre = time.clock()
bCanHu = check_hu_mgr.testHu(0, listCard, listJinPai)
nTimeENd = time.clock()
framework.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.CheckHU {0} ".format(nTimeENd - nTimeCheckPre))
if bCanHu is True:
evObj = MjEventObj(EMjEvent.ev_hu_normal, nOptMember, str(nCard))
mjMgr.AddEventNotic2Poll(nPos, evObj)
mjMgr.SetCurEventOptMember(nOptMember)
# 单游
if check_hu_mgr.CheckDanYou(listCard, listJinPai) is True:
evObj = MjEventObj(EMjEvent.ev_dan_you, nOptMember, str(nCard))
mjMgr.AddEventNotic2Poll(nPos, evObj)
if mjMgr.IsTuoGuan(nOptMember) is True:
tick_mgr.RegisterOnceTick(1000, mjMgr.RequestHu, [nOptMember])
framework.LOGINFO(
"FFSCENE_PYTHON", "GasMj.CanHu {0}, {1} ".format(
json.dumps(listJinPai), json.dumps(mjMgr.DumpPos(nPos))))
if listCard.count(nCard) == 4:
evObj = MjEventObj(EMjEvent.ev_gang_all, nOptMember, str(nCard))
mjMgr.AddEventNotic2Poll(nPos, evObj)
mjMgr.SetCurEventOptMember(nOptMember)
if mjMgr.IsTuoGuan(nOptMember):
tick_mgr.RegisterOnceTick(1000, mjMgr.RequestGang,
[nOptMember, nOptMember, nCard])
framework.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.GangAll {0}, {1} ".format(json.dumps(listCard), nCard))
return True
def StartQiPaiTick(self, nPos):
self.StopQiPaiTick(nPos)
nMember = self.m_roomObj.GetMemberIDByPos(nPos)
if util.IsRobot(nMember) is True:
nTick = tick_mgr.RegisterOnceTick(int(4 * 1000), self.AutoQiPai,
nPos)
elif self.IsTuoGuan(nMember) is True:
nTick = tick_mgr.RegisterOnceTick(int(1 * 1000), self.AutoQiPai,
nPos)
else:
nTick = tick_mgr.RegisterOnceTick(
int(self.GetQiPaiExpireSecond() * 1000), self.AutoQiPai, nPos)
self.m_dictOptTick[nPos] = nTick
def AddResidualPlayer(self, nPlayerGID):
assert nPlayerGID not in self.m_dictRsidualPlayer
nTickID = tick_mgr.RegisterOnceTick(RESIDUAL_TIME,
self.OnResdualTimeOut, nPlayerGID)
self.m_dictRsidualPlayer[nPlayerGID] = nTickID
Player = entity_mgr.GetEntity(nPlayerGID)
Player.SetResidual(True)
ffext.LOGINFO("FFSCENE_PYTHON",
"AddResidualPlayer {0}".format(nPlayerGID))
def CheckEnterRoom(self, nGID):
t = random.randint(10, 70)
t = int((t / 10.0) * 1000)
tick_mgr.RegisterOnceTick(t, self.CheckEnterRoom, nGID)
robotEntity = entity_mgr.GetEntity(nGID)
assert robotEntity is not None
if robotEntity.GetRoomID() is not None:
return
self.Try2EnterRoom(nGID)
def DispathWorkRet(self):
tick_mgr.RegisterOnceTick(self.m_nTick2CheckWorkQueue,
self.DispathWorkRet)
nQueueRandom = 0 # random.randint(0, self.m_nQueueNum - 1)
queueRet = self.m_dictChannel2QueueRet[0]
c = 0
while queueRet.empty() is False:
szScene, szSerial = self.m_dictChannel2QueueRet[nQueueRandom].get()
ffext.call_service(szScene, rpc_def.OnDbAsynCallReturn,
json.dumps(szSerial))
self.m_nProcessedJobNum += 1
c += 1
if c > 50:
break
print("dbs self.m_nProcessedJobNum ", self.m_nProcessedJobNum,
self.m_dictChannel2QueueRet[nQueueRandom].qsize())
def __init__(self):
import conf as conf
nRobotNum = conf.dict_cfg["gas"]["robot_num"]
self.m_nRobotStartID = (int(ff.service_name[-1:]) + 1) * 100
self.m_dictRobotGID = {}
import gas.gas_scene.gas_scene_mgr as gas_scene_mgr
for i in xrange(1, nRobotNum + 1):
import json
dict = {"ip": "127.0.0.1", "gate": "gate@0"}
gas_scene_mgr._gasSceneMgr.Gcc2GasSessionConn(
self.m_nRobotStartID, json.dumps(dict))
self.m_dictRobotGID[self.m_nRobotStartID] = False
self.m_nRobotStartID += 1
ffext.LOGINFO("FFSCENE_PYTHON",
"RobotMgr.CreateRobot {0} done.".format(nRobotNum))
for nGID in self.m_dictRobotGID.keys():
tick_mgr.RegisterOnceTick(5 * 1000, self.CheckEnterRoom, nGID)
import rpc.rpc_def as rpc_def
import rpc.scene_def as scene_def
import gcc.gcc_scene.gcc_scene_mgr as gcc_scene_mgr
import gcc.gcc_room_mgr.gcc_room_mgr as gcc_room_mgr
import service_ex.service_base as service_base
#
@ffext.reg_service(rpc_def.OnAllServiceStartUp)
def OnAllServiceStartUp(dictSerial):
import id_manager.room_id_mgr as room_id_mgr
room_id_mgr.init()
import robot.gm_opt_config as gm_opt_config
gm_opt_config.LoadAllConfig()
@ffext.reg_service(rpc_def.Peer)
def Peer(dictSerial):
ffext.call_service(scene_def.GATE_MASTER, rpc_def.RspPeer,
{"service": ff.service_name})
def A():
ffext.call_service(scene_def.GATE_MASTER, rpc_def.OnServiceConn,
{"service": ff.service_name})
import util.tick_mgr as tick_mgr
tick_mgr.RegisterOnceTick(100, A)
def TouchEventQiPai(self, mjMgr, listData):
nPos, nCard, nCardPos = listData
roomObj = mjMgr.GetRoomObj()
listMember = roomObj.GetMemberList()
nOptMember = roomObj.GetMemberIDByPos(nPos)
evObj = MjEventObj(EMjEvent.ev_be_qi_pai, nOptMember,
"{0},{1}".format(nCard, nCardPos + 1))
for nMember in listMember:
nMemberPos = roomObj.GetMemberPos(nMember)
mjMgr.AddEventNotic2Poll(nMemberPos, evObj)
# framework.send_msg_session(nMember, rpc_def.Gas2GacOnTouchGameEvent, szRspSerial)
listCardOwner = mjMgr.GetCardListByPos(nPos)
nTotal = len(listCardOwner)
assert ((nTotal - 1) % 3 == 0), nTotal
listJinPai = mjMgr.GetJinPaiList()
bNextTurn = True
for nMember in listMember:
if nMember == nOptMember:
continue
nMemberPos = mjMgr.GetRoomObj().GetMemberPos(nMember)
listCard = mjMgr.GetCardListByPos(nMemberPos)
listCardEx = mjMgr.GetCardListEx(nMemberPos)
# check gang, owenr have 3
if check_hu_mgr.testGang(nCard, listCard, listJinPai) is True:
evObj = MjEventObj(EMjEvent.ev_gang_other, nOptMember,
str(nCard))
mjMgr.AddEventNotic2Poll(nMemberPos, evObj)
mjMgr.SetCurEventOptMember(nMember)
if mjMgr.IsTuoGuan(nMember):
tick_mgr.RegisterOnceTick(1000, mjMgr.RequestGang,
[nMember, nOptMember, nCard])
framework.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.Gang {0}, {1} ".format(json.dumps(listCard), nCard))
bNextTurn = False
continue
# check gang with peng
if check_hu_mgr.testGang(nCard, listCardEx, listJinPai) is True:
evObj = MjEventObj(EMjEvent.ev_gang_with_peng, nOptMember,
str(nCard))
mjMgr.AddEventNotic2Poll(nMemberPos, evObj)
mjMgr.SetCurEventOptMember(nMember)
if mjMgr.IsTuoGuan(nMember):
tick_mgr.RegisterOnceTick(1000, mjMgr.RequestGang,
[nMember, nOptMember, nCard])
framework.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.Gang {0}, {1} ".format(json.dumps(listCard), nCard))
bNextTurn = False
continue
# check peng
if check_hu_mgr.testPeng(nCard, listCard, listJinPai) is True:
evObj = MjEventObj(EMjEvent.ev_peng, nOptMember, str(nCard))
mjMgr.AddEventNotic2Poll(nMemberPos, evObj)
mjMgr.SetCurEventOptMember(nMember)
if mjMgr.IsTuoGuan(nMember):
tick_mgr.RegisterOnceTick(1000, mjMgr.RequestPeng,
[nMember, nOptMember, nCard])
framework.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.Peng {0}, {1} ".format(json.dumps(listCard), nCard))
bNextTurn = False
continue
return bNextTurn
def NoticeAll(self):
for szService in self.m_dictAllService.iterkeys():
ffext.call_service(szService, rpc_def.OnAllServiceStartUp, {})
tick_mgr.RegisterOnceTick(5000, self.Peer)
def CheckServiceDisConn(self):
tick_mgr.RegisterOnceTick(5000, self.Peer)
for szService, nUpdTime in self.m_dictAllService.iteritems():
nGap = time.time() - nUpdTime
if nGap > 2 * self.m_nPeerGap:
self.OnServiceDisConn(szService)
def Peer(self):
tick_mgr.RegisterOnceTick(self.m_nPeerGap * 1000, self.Peer)
for szService in self.m_dictAllService.iterkeys():
ffext.call_service(szService, rpc_def.Peer, {})
def StartOnceTick(self):
self.StopOnceTick()
self.m_nTick2Persistent = tick_mgr.RegisterOnceTick(
g_nPersistentGap, self.OnTimerPersistent)
def ServiceCheckTick():
tick_mgr.RegisterOnceTick(10000, ServiceCheckTick)
ffext.call_service(g_szServiceMgr, 0, "test aaa")
def DoConnPring(self):
tick_mgr.RegisterOnceTick(60 * 60 * 1000, self.DoConnPring)
import dbs_common as dbs_common
dbs_common.Ping(self.m_nConn)
