def reqEnterRoom(self, player):
"""
先查找空房间，如果没空房，则将玩家排队，然后创建新房间
"""
for roomData in self.childs.values():
if len(roomData['players']) < 3:
roomData['players'].append(player)
if roomData['roomMailbox']:
roomData['roomMailbox'].reqEnter(player)
return
self.lastNewRoomKey = self.lastNewRoomKey + 1
params = {'parent':self,
'cid': self.lastNewRoomKey,
'state': 0,
'difen': d_DDZ[self.cid]['base'],
'taxRate': d_DDZ['taxRate']}
KBEngine.createEntityAnywhere("DdzRoom", params, None)
roomDatas = {"roomMailbox": None,
"players": [player]}
self.childs[self.lastNewRoomKey] = roomDatas
def findRoom(self, roomKey, notFoundCreate = False):
"""
查找一个指定房间，如果找不到允许创建一个新的
"""
roomDatas = self.rooms.get(roomKey)
# 如果房间没有创建，则将其创建
if not roomDatas:
if not notFoundCreate:
return FIND_ROOM_NOT_FOUND
# 如果最后创建的房间没有满员，则使用最后创建的房间key，否则产生一个新的房间唯一Key
roomDatas = self.rooms.get(self.lastNewRoomKey)
if roomDatas is not None and roomDatas["PlayerCount"] < GameConfigs.ROOM_MAX_PLAYER:
return roomDatas
self.lastNewRoomKey = KBEngine.genUUID64()
# 将房间base实体创建在任意baseapp上
# 此处的字典参数中可以对实体进行提前def属性赋值
KBEngine.createEntityAnywhere("Room", \
{
"roomKey" : self.lastNewRoomKey, \
}, \
Functor.Functor(self.onRoomCreatedCB, self.lastNewRoomKey))
roomDatas = {"roomEntityCall" : None, "PlayerCount": 0, "enterRoomReqs" : [], "roomKey" : self.lastNewRoomKey}
self.rooms[self.lastNewRoomKey] = roomDatas
return roomDatas
return roomDatas
def findRoom(self, roomKey):
roomData = self.rooms.get(roomKey)
if roomData is None:
roomData = self.rooms.get(self.lastNewRoomKey)
if((roomData is not None) and \
(roomData["playerCount"] < GameConfigs.ROOM_MAX_PLAYER) and\
(roomData["roomState"] < GameConstants.GAMESTATE_END) and\
(not roomData["arriveMinTimeFlag"])):
return roomData
self.lastNewRoomKey = KBEngine.genUUID64()
params = {
"roomKey": self.lastNewRoomKey, # base, BASE_AND_CLIENT
}
KBEngine.createEntityAnywhere(
"Room", params,
Functor.Functor(self.onRoomCreatedCB, self.lastNewRoomKey))
roomData = {
"roomEntityCall": None,
"playerCount": 0,
"enterRoomReqs": [],
"roomKey": self.lastNewRoomKey
}
self.rooms[self.lastNewRoomKey] = roomData
return roomData
else:
return roomData
def reqEnterRoom(self, player):
"""
先查找空房间，如果没空房，则将玩家排队，再创建新房间
"""
roomKey = self.findNotFullRooms()
if roomKey:
room = self.childs[roomKey]["roomMailbox"]
self.childs[roomKey]["players"].append(player)
self.sortNotFullRooms(roomKey, self.childs[roomKey]["players"])
room.reqEnter(player)
else:
self.lastNewRoomKey = self.lastNewRoomKey + 1
params = {
'parent': self,
'cid': self.lastNewRoomKey,
'state': 0,
'dizhu': d_ZJH[self.cid]['base'],
'jzList': json.dumps(d_ZJH[self.cid]['jzList']),
'taxRate': d_ZJH['taxRate']
}
KBEngine.createEntityAnywhere("ZjhRoom", params, None)
roomDatas = {"roomMailbox": None, "players": [player]}
self.childs[self.lastNewRoomKey] = roomDatas
self.sortNotFullRooms(self.lastNewRoomKey, roomDatas["players"])
def createPrivateRoom(self, entityCall, position, direction):
#DEBUG_MSG("Hall createPrivateRoom" % (self.id))
#生成一个64位的唯一id,作为房间的id
self.PrivatelastNewRoomKey = KBEngine.genUUID64()
DEBUG_MSG("Hall createPrivateRoom generator key %i" %
(self.PrivatelastNewRoomKey))
# 将房间base实体创建在任意baseapp上
# 此处的字典参数中可以对实体进行提前def属性赋值
KBEngine.createEntityAnywhere("PrivateRoom", \
{
"roomKey" : self.PrivatelastNewRoomKey, \
}, \
Functor.Functor(self.onPrivateRoomCreatedCB, self.PrivatelastNewRoomKey))
roomDatas = {
"roomEntityCall": None,
"PlayerCount": 0,
"enterRoomReqs": [],
"roomKey": self.PrivatelastNewRoomKey,
"userindex": {
100: 100
}
}
self.Privaterooms[self.PrivatelastNewRoomKey] = roomDatas
roomDatas["enterRoomReqs"].append((entityCall, position, direction))
roomDatas["PlayerCount"] += 1
def matchSuccess(self, ballteSpace, index):
DEBUG_MSG("Account[%i].matchSuccess battleSpace[%i]" %
(self.id, ballteSpace.id))
self.track = index
#方向为弧度 用角度换算弧度
params = {
"Account": self,
"BattleFieldCell": ballteSpace.cell,
"name": self.Name,
"dbid": self.databaseID,
"position": BattleSpacePosConfigs.getInitAvatarPos(index),
"direction": [0, (index * 72 / 360) * (2 * math.pi), 0],
"track": index,
}
#回调函数
def callBack(result):
if result == None:
ERROR_MSG(result)
else:
DEBUG_MSG("Create Avatar[%i] Success" % result.id)
ballteSpace.baseAvatars[result.id] = result
self.battleSpace = ballteSpace
self.client.enterBattleSpace()
self.Avatar = result
KBEngine.createEntityAnywhere("Avatar", params, callBack)
def findSpace(self, spaceKey, notFoundCreate=False):
spaceDatas = self._spaceAllocs.get(spaceKey)
if not spaceDatas:
if not notFoundCreate:
return FIND_SPACE_NOT_FOUND
spaceDatas = self._spaceAllocs.get(self.lastNewSpaceKey)
if spaceDatas is not None and spaceDatas[
'PlayerCount'] < GameConfigs.SPACE_MAX_PLAYER:
return spaceDatas
self.lastNewSpaceKey = KBEngine.genUUID64()
KBEngine.createEntityAnywhere("Space",\
{
"SpaceKey":self.lastNewSpaceKey,\
},
Functor.Functor(self.onSpaceCreateCB,self.lastNewSpaceKey))
spaceDatas = {
"spaceEntityCall": None,
"PlayerCount": 0,
"enterSpaceReqs": [],
"SpaceKey": self.lastNewSpaceKey
}
self._spaceAllocs[self.lastNewSpaceKey] = spaceDatas
return spaceDatas
return spaceDatas
def _createSiteEntity(self, entityCall):
site_id = 1
KBEngine.createEntityAnywhere(
"BusStation", {
"name": "Bus Station",
"room_id": self.roomKey,
"location": site_id,
"curr_player": entityCall
}, Functor.Functor(self._createSiteCB, site_id))
def requestCreateRoom(self, player, roomName):
tempRoomID = tempRoomID + 1
params = {
"ID": tempRoomID,
"Name": roomName,
"Lobby": self,
"Players": [],
"Creator": player
}
KBEngine.createEntityAnywhere("Room", params, onCreateRoomCallback)
def systemCreateRoom(self,playerNum):
playerEntityList=[]
for i in range(playerNum):
playerEntityList.append(self.matchPlayerEntity.pop(0))
roomId=KBEngine.genUUID64() #服务器自动生成64位的ID
while roomId in self.allRoomEntity: #检测房间ID是否重复
roomId=KBEngine.genUUID64()
#创建房间实体
KBEngine.createEntityAnywhere("Room",{"roomId":roomId,"roomType":0,"playerList":playerEntityList},Functor.Functor(self.systemCreateRoomCB,roomId))
def onTimer(self, id, userArg):
"""
KBEngine method.
使用addTimer后， 当时间到达则该接口被调用
@param id : addTimer 的返回值ID
@param userArg : addTimer 最后一个参数所给入的数据
"""
for key,value in d_games.items():
params = {'parent':self,'cid': key,'open': value["open"]}
KBEngine.createEntityAnywhere(value['sign']+"Game",params,Functor(self.onCreateBaseCallback,key))
def onCreateSpace(self, avatarEntity):
"""
客户端请求创建一个空间
"""
spaceKey = KBEngine.genUUID64()
KBEngine.createEntityAnywhere('Space', \
{\
"spaceKey" : spaceKey, \
"spaceState": GlobalDefine.SPACE_STATE_UNKNOW,\
}, \
Functor.Functor(self.onSpaceCreatedCB, spaceKey,avatarEntity))
def _creatRoomEntity(self, entityList, roomType=0):
roomId = self.generateRoomId()
if self.allRoomEntityList.get(roomId, None) != None:
self._creatRoomEntity(entityList, roomType)
KBEngine.createEntityAnywhere(
"Room", {
"roomKey": roomId,
"RoomType": roomType,
"EnterPlayerList": entityList,
"playerMaxCount": ROOM_MAX_PLAYER
}, Functor.Functor(self._CreatRoomCB, roomId))
def createRoom(self, matchId):
DEBUG_MSG("Matcher_createRoom::matchId[%i]" % matchId)
matchData = self.matchPools[matchId]
matchData["state"] = MATCH_STATE_ROOM_CREATION_BEGIN
params = {"compMatcherRoom": {"roomKey": matchId, "roomKeyC": matchId}}
KBEngine.createEntityAnywhere(
self.roomName, params,
Functor.Functor(self.onRoomCreatedCB, matchId))
playersData = matchData["playersData"]
self.broadcastMatchState(playersData, matchData["state"])
def match(self):
"""
匹配逻辑
"""
# 关闭计时器
if len(self.matchPlayers) == 0 and self.matchTimer != 0:
self.delTimer(self.matchTimer)
self.matchTimer = 0
return
playerCount = len(self.matchPlayers)
for room in self.publicRooms.values():
need = room.needPlayerCount()
if need == 0:
continue
# 玩家是否充裕
if playerCount > need:
for i in range(need):
room.enterRoom(self.matchPlayers.pop(0))
else:
for i in range(playerCount):
room.enterRoom(self.matchPlayers.pop(0))
# 是否完成匹配
playerCount = len(self.matchPlayers)
if playerCount == 0:
return
# 如果还剩玩家，就创建房间给他们
roomCount = int(playerCount / ROOM_MAX_PLAYER) + 1
print("Match: 当前玩家人数(%i)需要创建房间(%i)" % (playerCount, roomCount))
for i in range(roomCount):
players = []
# 玩家少
if playerCount < ROOM_MAX_PLAYER:
for i in range(playerCount):
players.append(self.matchPlayers.pop(0))
else:
for i in range(ROOM_MAX_PLAYER):
players.append(self.matchPlayers.pop(0))
playerCount = len(self.matchPlayers)
roomKey = self.generatePublicKey()
print("Match: 创建房间(%i)" % roomKey)
KBEngine.createEntityAnywhere(
"Room", {
"playerList": players,
"isPrivate": 0,
"roomKey": roomKey
}, Functor.Functor(self.onCreateRoom, roomKey, False))
def createSpace(self, spaceKey, context):
"""
"""
if spaceKey <= 0:
spaceKey = KBEngine.genUUID64()
context = copy.copy(context)
spaceData = d_spaces.datas.get(self._utype)
KBEngine.createEntityAnywhere(spaceData["entityType"], \
{"spaceUType" : self._utype, \
"spaceKey" : spaceKey, \
"context" : context, \
}, \
Functor.Functor(self.onSpaceCreatedCB, spaceKey))
def _createRoomEntity(self, entityList, roomType=0):
roomId = self.generateRoomId()
print("_createRoomEntity roomId:", roomId)
if self.allRoomEntityList.get(roomId, None) is not None:
self._createRoomEntity(entityList, roomType)
props = {
"roomKey": roomId,
"RoomType": roomType,
"EnterPlayerList": entityList,
"MaxPlayerCount": ROOM_MAX_PLAYER
}
print("_createRoomEntity props:")
KBEngine.createEntityAnywhere(
"Room", props, Functor.Functor(self._createRoomCB, roomId))
def _initMatchServer(self):
"""
初始化匹配实体
"""
for roomType in GDefine.GC_RoomType.values():
# 自建房不需要匹配服务
if roomType == GDefine.GC_RoomType['Create']:
continue
param = {
'roomType': roomType,
'masterHalls': self,
}
KBEngine.createEntityAnywhere('matchServer', param)
def MatchSuccess(self,players):
DEBUG_MSG("Hall: MatchSuccess player")
prarms = {
"Player0":players[0],
"Player1":players[1]
}
Battlefield = KBEngine.createEntityAnywhere("Battlefield",prarms)
def _onCityCreatedFromDBIDCB(self, baseRef, databaseId, wasActive):
"""
一个City创建好后的回调
"""
DEBUG_MSG("Spaces::onCityCreatedCB: city. databaseId=%i" %
(databaseId))
if wasActive:
ERROR_MSG(
"Space::onCityCreatedCB:(%i): this city is in world now!" %
(self.id))
return
if baseRef is None:
KBEngine.createEntityAnywhere("City", {"CityID": databaseId},
self.onCityCreatedCB)
ERROR_MSG(
"Space::onCityCreatedCB:(%i): the city you wanted to created is not exist!"
% (self.id))
return
def createRoom(self, account):
"""
创建房间
"""
# 有没有空房间
for room in self.privateRooms.values():
if room.needPlayerCount() == ROOM_MAX_PLAYER:
room.enterRoom(account)
return
# 没有空房间就创建一个
roomKey = self.generatePrivateKey()
KBEngine.createEntityAnywhere(
"Room", {
"playerList": [account],
"isPrivate": 1,
"roomKey": roomKey
}, Functor.Functor(self.onCreateRoom, roomKey, True))
def demo_createDemoRoom(self):
# self.tempRoomID = self.tempRoomID + 1
params = {
"ID": 0,
"Name": "Demo",
"Lobby": self,
"Players": [],
}
self.rooms.append(KBEngine.createEntityAnywhere("Room", params))
def spawnOnTimer(self, tid):
"""
出生怪物
"""
if len(self.tmpCreateEntityDatas) <= 0:
self.delTimer(tid)
return
datas = self.tmpCreateEntityDatas.pop(0)
if datas is None:
ERROR_MSG("Space::onTimer: spawn %i is error!" % datas[0])
KBEngine.createEntityAnywhere("SpawnPoint",
{"spawnEntityNO" : datas[0], \
"position" : datas[1], \
"direction" : datas[2], \
"modelScale" : datas[3], \
"createToCell" : self.cell})
def onClientEnabled(self):
"""
KBEngine method.
该entity被正式激活为可使用， 此时entity已经建立了client对应实体， 可以在此创建它的
cell部分。
"""
INFO_MSG(
"Account base::onClientEnabled:id:%s,name:%s,winCount:%s,loseCount:%s"
% (self.id, self.name, self.winCount, self.loseCount))
#是否被封禁
DEBUG_MSG("account base::bansList:%s" % self.bansList)
if len(self.bansList) > 0:
maxFinishTime = "0"
maxKey = 0
for key, val in self.bansList.items():
if maxFinishTime < val[3]:
maxKey = key
ban = self.bansList[maxKey]
DEBUG_MSG("account base::latest ban:%s" % ban)
ban = ban.asDict()
if ban["state"] == 1:
nowDateTime = datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
DEBUG_MSG("nowDateTime:%s" % nowDateTime)
if nowDateTime > ban["startTime"] and nowDateTime < ban[
"finishTime"]:
DEBUG_MSG("this account is banned")
self.client.isBan(ban["startTime"], ban["finishTime"])
return
if self.name == "":
self.client.onEnterSetName(self.name)
else:
self.client.onEnterHall(self.id)
KBEngine.createEntityAnywhere("Log", \
{
"accountId" : self.databaseID,
"action" : "login",
"value" : "",
"time" : datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
})
def matchSuccess(self, players):
# DEBUG_MSG("Hall[%i].matchSuccess : teamPlayerName [%s] [%s] [%s] [%s] [%s]"
# % (self.id, players[0].Name, players[1].Name, players[2].Name, players[3].Name, players[4].Name))
DEBUG_MSG("Hall[%i].matchSuccess : teamPlayerName [%s] [%s]" %
(self.id, players[0].Name, players[1].Name))
params = {
"AccountList": players,
}
battleSpace = KBEngine.createEntityAnywhere("BattleSpace", params)
def createMatcherRoom(self):
"""
创建房间
:param entityCall:
:return:
"""
DEBUG_MSG("Matcher::createMatcherRoom: matchID: %i. self.state=%i" %
(self.matchID, self.state))
if self.state != GlobalDefine.MATCHER_STATE_CREATE_ROOM:
DEBUG_MSG(
"create room is not MATCHER_STATE_CREATE_ROOM state : %s")
return ErrorCode.ERROR_ROOM_CREATE_NOT_READY
params = {"compMatchRoom": {"roomKey": self.roomRule.roomKey}}
KBEngine.createEntityAnywhere(
"Room", params,
Functor.Functor(self.onRoomCreatedCB, self.roomRule.roomKey))
return ErrorCode.ERROR_OK
def reqCreateRoom(self, entityCall, name, intro, password):
"""
请求创建房间
"""
DEBUG_MSG("Hall::reqCreateRoom:name:%s,intro:%s，password:%s" %
(name, intro, password))
if name == "":
return 31
if intro == "":
return 32
self.newRoomKey = KBEngine.genUUID64()
KBEngine.createEntityAnywhere("Room", \
{
"roomKey" : self.newRoomKey,
"name" : name,
"intro" : intro,
"password" : password
}, \
Functor.Functor(self.onRoomCreatedCB, self.newRoomKey))
if password == "":
hasPassword = 1
else:
hasPassword = 2
roomDatas = {
"roomEntityCall": None,
"playerCount": 0,
"roomKey": self.newRoomKey,
"name": name,
"intro": intro,
"password": password,
"isPlaying": 1,
"hasPassword": hasPassword,
"enterRoomReqs": []
}
self.rooms[self.newRoomKey] = roomDatas
DEBUG_MSG("Hall::reqCreateRoom:rooms:%s" % self.rooms)
entityCall.reqJoinRoom(self.newRoomKey, password)
def _createRoom(self, roomType, avList):
"""
创建房间
参数1：房间类型
参数2：房间内玩家列表
"""
param = {
# 大厅信息
'masterHalls': self,
'masterHallsName': self.hallsName,
# 房间基本属性
'roomID': 100000,
'roomType': roomType,
'roomName': 'gobangRoom',
'gameID': self.gameID,
# 房间内玩家
'maxPlayerCount': 2,
'playerList': avList,
}
KBEngine.createEntityAnywhere('gobangRoom', param)
def findRoom(self, roomKey, notFoundCreate = False):
roomDatas = self.rooms.get(roomKey)
if not roomDatas:
if not notFoundCreate:
return FIND_ROOM_NOT_FOUND
roomDatas = self.rooms.get(self.lastNewRoomKey)
if roomDatas is not None:
return roomDatas
self.lastNewRoomKey = KBEngine.genUUID64()
KBEngine.createEntityAnywhere("Room", \
{"roomKey" : self.lastNewRoomKey,}, \
Functor.Functor(self.onRoomCreatedCB, self.lastNewRoomKey))
roomDatas = {"roomEntityCall":None, "PlayerCount": 0, "enterRoomReqs" : [], "roomKey" : self.lastNewRoomKey}
self.rooms[self.lastNewRoomKey] = roomDatas
return roomDatas
return roomDatas
def callback(content):
if content is None:
DEBUG_MSG(
"createRoom callback error: content is None, user id {}".
format(self.userId))
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
# try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(game_round, pay_mode)
if not KBEngine.globalData[
"GameWorld"].free_play and card_cost > data[
"card"] and diamond_cost > data["diamond"]:
self.createRoomFailed(const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
# @formatter:off
params = {
'owner_uid': self.userId,
'king_num': 0,
'player_num': player_num,
'game_round': game_round,
'pay_mode': pay_mode,
'game_mode': game_mode,
'max_lose': max_lose,
'lucky_num': lucky_num,
'discard_seconds': 0,
'hand_prepare': hand_prepare,
'room_type': room_type,
}
# @formatter:on
KBEngine.createEntityAnywhere("GameRoom", params,
self.createRoomCallback)
