def __init__(self): super(SimpleServer, self).__init__() self.id_counter = 0 self.last_time = datetime.now() self.player_count = 0 # 当前连入玩家数 self.host = SimpleHost() self.dispatcher = Dispatcher() self.room = None self.id2player_info = {} self.id2client = {}
class SimpleServer(object): def __init__(self): super(SimpleServer, self).__init__() self.entities = {} self.host = SimpleHost() self.host.startup(50000) self.dispatcher = Dispatcher() self.initServices() return def generateEntityID(self): raise NotImplementedError def registerEntity(self, entity): eid = self.generateEntityID entity.id = eid self.entities[eid] = entity return def initServices(self): login_service = LoginService(conf.MSG_CS_LOGIN) self.dispatcher.register(conf.MSG_CS_LOGIN, login_service) def tick(self): self.host.process() while 1: event, owner, data = self.host.read() if event < 0: #所有事件处理完毕 break elif event == conf.NET_CONNECTION_NEW: #TODO pass elif event == conf.NET_CONNECTION_LEAVE: #TODO pass elif event == conf.NET_CONNECTION_DATA: self.dispatcher.dispatch(data, owner) for eid, entity in self.entities.iteritems(): # Note: you can not delete entity in tick. # you may cache delete items and delete in next frame # or just use items. entity.tick() return
def __init__(self): super(SimpleServer, self).__init__() self.host = SimpleHost() self.gamescene = GameScene() self.loginServer = LoginServer() self.dispatch = Dispatcher() self.entities = {} self.messageHandler = {} self.enemyManager = EnemyManager(self) self.playerManager = PlayerManager(self) self.trapManager = TrapManager(self) self.routerManager = RouteManager(self) self.combatManager = CombatManager(self) self.economySys = EconomySys(self) self.RegisterMessageHandler(conf.MSG_CS_MOVETO, self.playerManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_ATTACK, self.playerManager.MsgHandler) #self.RegisterMessageHandler(conf.MSG_CS_ATTACK, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_GAME_REPLAY, self.playerManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_GAME_REPLAY, self.enemyManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_GAME_REPLAY, self.combatManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_GAME_REPLAY, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_SS_GAME_OVER, self.enemyManager.MsgHandler) #self.RegisterMessageHandler(conf.MSG_SS_GAME_OVER, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_ENEMY_ATTACK, self.enemyManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_TRAP_IN, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_TRAP_ATTACK, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_BUY, self.economySys.MsgHandler) return
def __init__(self): super(SimpleServer, self).__init__() self.entities = {} self.host = SimpleHost() self.host.startup(50000) self.dispatcher = Dispatcher() self.initServices() return
def __init__(self, host, port): super(Server, self).__init__() # Start host self.host = SimpleHost() self.host.startup(host, port) # login user dict self.login_user_map = {} # user room map self.user_room_map = {} # rooms self.rooms = [] # Generate dispatcher self.dispatcher = Dispatcher() self.register_dispatcher_services() # map msg_type to message object self.msg_dict = None self.generate_msg_dict()
def __init__(self, host, port): super(Server, self).__init__() # Start host self.host = SimpleHost() self.host.startup(host, port) self.host.db_manager = DBManager(conf.DB_NAME) self.host.room_manager = RoomManager(self.host) self.user_services = UserServices(self.host) # rooms self.rooms = [] # Generate dispatcher self.dispatcher = Dispatcher() self.register_dispatcher_services() # map msg_type to message object self.msg_dict = None self.generate_msg_dict()
def __init__(self): super(SimpleServer, self).__init__() self.entities = { constants.PLAYER_ENTITY_TYPE: {}, constants.MONSTER_ENTITY_TYPE: {}, constants.TRAP_ENTITY_TYPE: {}, constants.MISSILE_ENTITY_TYPE: {} } self.host = SimpleHost() self.dispatcher = Dispatcher() self.initDispatcher() self._start_server = False self._game_start = False self._next_entity_id = 0 self.message_queue = { constants.SEND_SINGLE: [], # (client_id, msg) constants.SEND_BROADCAST: [], # msg constants.SEND_EXCEPT: [] # (client_id, msg) } self.ready_to_delete_entities = { constants.PLAYER_ENTITY_TYPE: [], constants.MONSTER_ENTITY_TYPE: [], constants.TRAP_ENTITY_TYPE: [], constants.MISSILE_ENTITY_TYPE: [] } self.host.startup(conf.SERVER_PORT) self.game_db = game_db self.enemy_move_manager = enemy_move_module self.game_level = 0 self.during_start_game_level = False self.login_successful_clients = []
class SimpleServer(object): def __init__(self): super(SimpleServer, self).__init__() self.id_counter = 0 self.last_time = datetime.now() self.player_count = 0 # 当前连入玩家数 self.host = SimpleHost() self.dispatcher = Dispatcher() self.room = None self.id2player_info = {} self.id2client = {} def tick(self): self.host.process() return def dispatch(self, data, owner): """ 消息派发 :param data: 原始数据 :param owner: 接收的客户端 """ # 当用户异常退出时发送FIN,data的长度为0 if len(data) == 0: return p = Packet(data) opcode = p.get_int16() def str_to_hex(s): return ":".join("{:02x}".format(ord(c)) for c in s) print(str_to_hex(data)) # print u'获得opcode:%d' % opcode if opcode == conf.MSG_JOIN_ROOM: self.player_join_room(opcode, p, owner) elif opcode == conf.MSG_PLAYER_INPUT: self.player_input(opcode, p, owner) elif opcode == conf.MSG_QUIT_ROOM: self.player_input(opcode, p, owner) else: raise Exception(u'bad opcode %d' % opcode) def player_join_room(self, opcode, packet, client): # Todo 从数据库读取用户信息 msg = MessageJoinRoom() msg.deserialize(packet) player_name = msg.name + str(self.id_counter) info = PlayerInfo(player_name, self.id_counter, self.id_counter) print u'玩家:%s连入' % info.name self.id_counter += 1 self.player_count += 1 self.id2player_info[info.id] = info self.id2client[info.id] = client client.player_info = info if self.player_count >= Room.max_count: self.room = Room() for info in self.id2player_info.values(): client = self.id2client[info.id] self.room.add_player(info, client) self.room.start_game() def player_quit_room(self, opcode, packet, client): player_info = client.player_info if player_info is None: return self.player_count -= 1 player_id = player_info.id del self.id2client[player_id] del self.id2player_info[player_id] if self.player_count == 0: self.room = None def player_input(self, opcode, packet, client): if self.room is None: return msg = MessagePlayerInput() msg.deserialize(packet) player_info = client.player_info self.room.set_input(player_info, msg) def update(self): """ 每30ms更新一次,主要用于帧同步 """ now = datetime.now() delta_time = (now - self.last_time).total_seconds() if delta_time < 0.03: return self.last_time = now if self.room is None: return self.room.update()
class Server(object): def __init__(self, host, port): super(Server, self).__init__() # Start host self.host = SimpleHost() self.host.startup(host, port) self.db_manager = DBManager(conf.DB_NAME) self.room_manager = RoomManager(self.host) self.user_services = UserServices(self.host, self.db_manager, self.room_manager) # rooms self.rooms = [] # Generate dispatcher self.dispatcher = Dispatcher() self.register_dispatcher_services() # map msg_type to message object self.msg_dict = None self.generate_msg_dict() def register_dispatcher_services(self): self.dispatcher.register(conf.USER_SERVICES, self.user_services) # register MatchServices def generate_msg_dict(self): self.msg_dict = { conf.MSG_CS_REGISTER: events.MsgCSRegister(), conf.MSG_CS_LOGIN: events.MsgCSLogin(), conf.MSG_CS_LOGOUT: events.MsgCSLogout() } def tick(self): # Try send and receive message self.host.process() # handle received message self.handle_received_msg() self.room_manager.tick() def handle_received_msg(self): try: # read message from host queue event, client_hid, data = self.host.read() if event == conf.NET_CONNECTION_DATA: # read client data msg_type = Header.get_htype_from_raw(data)[0] if msg_type in self.msg_dict: msg = self.msg_dict[msg_type] msg.unmarshal(data) # Dispatch message self.dispatcher.dispatch(msg, client_hid) else: # message not register, let room handle it if client_hid in self.user_services.client_hid_to_user_map: self.host.room_manager.handle_received_msg( msg_type, data, client_hid) else: print "handle received message error: client not in any room" elif event == conf.NET_CONNECTION_LEAVE: self.dispatcher.dispatch(self.msg_dict[conf.MSG_CS_LOGOUT], client_hid) elif event == conf.NET_CONNECTION_NEW: print "No implemented !!!!!!!!" except: print "Handle received message error !!!!!!!!"
class SimpleServer(object): def __init__(self): super(SimpleServer, self).__init__() self.host = SimpleHost() self.gamescene = GameScene() self.loginServer = LoginServer() self.dispatch = Dispatcher() self.entities = {} self.messageHandler = {} self.enemyManager = EnemyManager(self) self.playerManager = PlayerManager(self) self.trapManager = TrapManager(self) self.routerManager = RouteManager(self) self.combatManager = CombatManager(self) self.economySys = EconomySys(self) self.RegisterMessageHandler(conf.MSG_CS_MOVETO, self.playerManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_ATTACK, self.playerManager.MsgHandler) #self.RegisterMessageHandler(conf.MSG_CS_ATTACK, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_GAME_REPLAY, self.playerManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_GAME_REPLAY, self.enemyManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_GAME_REPLAY, self.combatManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_GAME_REPLAY, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_SS_GAME_OVER, self.enemyManager.MsgHandler) #self.RegisterMessageHandler(conf.MSG_SS_GAME_OVER, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_ENEMY_ATTACK, self.enemyManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_TRAP_IN, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_TRAP_ATTACK, self.trapManager.MsgHandler) self.RegisterMessageHandler(conf.MSG_CS_BUY, self.economySys.MsgHandler) return def SendMessageSS(self, msg): for hd in self.messageHandler[msg.command]: hd(self.host, -1, msg) def RegisterMessageHandler(self, msgCommond, func): if self.messageHandler.has_key(msgCommond) == False: self.messageHandler[msgCommond] = [] if func not in self.messageHandler[msgCommond]: self.messageHandler[msgCommond].append(func) def UnRegisterMessageHandler(self, msgCommond, func): if func in self.messageHandler[msgCommond]: self.messageHandler[msgCommond].remove(func) def generateEntityID(self): raise NotImplementedError def registerEntity(self, entity): eid = self.generateEntityID entity.id = eid self.entities[eid] = entity return def commondExtract(self, data): try: cm = data[0:4] cmdcode = struct.unpack('<i', cm)[0] if cmdcode == conf.MSG_CS_LOGIN: msg = MsgCSLogin(data[4:]) return msg elif cmdcode == conf.MSG_CS_MOVETO: msg = MsgCSMoveTo(data[4:]) return msg elif cmdcode == conf.MSG_CS_ATTACK: msg = MsgCSAttack(data[4:]) return msg elif cmdcode == conf.MSG_CS_GAME_REPLAY: msg = MsgCSGameReplay(data[4:]) return msg elif cmdcode == conf.MSG_CS_ENEMY_ATTACK: msg = MsgCSEnemyAttack(data[4:]) return msg elif cmdcode == conf.MSG_CS_TRAP_IN: msg = MsgCSTrapIn(data[4:]) return msg elif cmdcode == conf.MSG_CS_BUY: msg = MsgCSBuy(data[4:]) return msg elif cmdcode == conf.MSG_CS_TRAP_ATTACK: msg = MsgCSTrapAttack(data[4:]) return msg except: return None def msgProcess(self, handlers, cid, msg): for hd in handlers: hd(self.host, cid, msg) def startServer(self): self.host.startup('127.0.0.1', 5001) while 1: #time.sleep(0.1) self.host.process() self.enemyManager.Process(self.host) self.playerManager.Process(self.host) self.trapManager.Process(self.host) self.combatManager.Process(self.host) self.routerManager.Process(self.host) event, wparam, data = self.host.read() if event < 0: continue if event == conf.NET_CONNECTION_DATA: msg = self.commondExtract(data) msg.cid = wparam if type(msg) is MsgCSLogin: retval, userID = self.LoginProcedure( self.host, msg, wparam) if retval == True: if self.enemyManager.gameover == True: self.enemyManager.gameover = False self.playerManager.RegisterLiveClient( self.host, wparam, userID) self.enemyManager.RegisterLiveClient( self.host, wparam, userID) self.trapManager.RegisterLiveClient( self.host, wparam, userID) self.economySys.RegisterLiveClient(wparam, userID) self.combatManager.RegisterLiveClient(wparam, userID) elif type(msg) is MsgCSGameReplay: self.msgProcess(self.messageHandler[msg.GetMsgCommand()], wparam, msg) else: self.msgProcess(self.messageHandler[msg.GetMsgCommand()], wparam, msg) #self.host.closeClient(wparam) #self.host.shutdown() elif event == conf.NET_CONNECTION_LEAVE: self.playerManager.UnregisterClient(wparam) self.enemyManager.UnregisterClient(wparam) self.trapManager.UnregisterClient(wparam) self.economySys.UnregisterClient(wparam) self.combatManager.UnregisterClient(wparam) #Save Data into the database elif event == conf.NET_CONNECTION_NEW: pass #Idle def LoginProcedure(self, host, msg, cid): retMsg = MsgSCConfirm() if msg.getStat() == msg.MSG_STAT_OK: stat, userID = self.loginServer.userPasswordConfirm( msg.getUsername(), msg.getPassword()) if stat == 1: retMsg.msgData = retMsg.MSG_OK retMsg.userID = userID else: retMsg.msgData = retMsg.MSG_ERR_PW else: retMsg.msgData = retMsg.MSG_ERR_PROG data = retMsg.getPackedData() host.sendClient(cid, data) if retMsg.msgData == retMsg.MSG_OK: return True, retMsg.userID return False, retMsg.userID
class Server(object): def __init__(self, host, port): super(Server, self).__init__() # Start host self.host = SimpleHost() self.host.startup(host, port) # login user dict self.login_user_map = {} # user room map self.user_room_map = {} # rooms self.rooms = [] # Generate dispatcher self.dispatcher = Dispatcher() self.register_dispatcher_services() # map msg_type to message object self.msg_dict = None self.generate_msg_dict() def register_dispatcher_services(self): """ Register services to dispatcher """ self.dispatcher.register( conf.USER_SERVICES, UserServices(self.host, self.login_user_map, self.rooms, self.user_room_map)) def generate_msg_dict(self): """ Map msg_type to message object """ self.msg_dict = { conf.MSG_REGISTER: events.MsgRegister(), conf.MSG_LOGIN: events.MsgLogin(), conf.MSG_LOGOUT: events.MsgLogout(), conf.MSG_CREATE_ROOM: events.MsgCreateRoom(), conf.MSG_JOIN_ROOM: events.MsgJoinRoom(), conf.MSG_LEAVE_ROOM: events.MsgLeaveRoom(), conf.MSG_START_GAME: events.MsgStartGame(), } def tick(self): # Try send and receive message self.host.process() # handle received message self.handle_received_msg() # update room status for room in self.rooms: if not room: continue room.tick() def handle_received_msg(self): """ Handle received message from host """ try: # read message from host queue event, client_hid, data = self.host.read() if event == conf.NET_CONNECTION_DATA: # read client data msg_type = Header.get_htype_from_raw(data)[0] if msg_type in self.msg_dict: msg = self.msg_dict[msg_type] msg.unmarshal(data) self.dispatcher.dispatch(msg, client_hid) else: # message not register, let room handle it if client_hid in self.user_room_map: self.user_room_map[client_hid].handle_received_msg( msg_type, data, client_hid) else: print "handle received message error: client not in any room" elif event == conf.NET_CONNECTION_LEAVE: self.dispatcher.dispatch(self.msg_dict[conf.MSG_LOGOUT], client_hid) except: print "Handle received message error !!!!!!!!"
def test_Parser(self): # test header data = self._head1.marshal() head = MsgCSLogin().unmarshal(data) self.assertEqual(self._head1.name, head.name) self.assertEqual(self._head1.password, head.password) data = self._head2.marshal() head = MsgCSMoveto().unmarshal(data) self.assertEqual(self._head2.x, head.x) self.assertEqual(self._head2.y, head.y) # test dispatcher msg = MsgService() msg.sid = 100 msg.cid = 10 self.assertEqual(self._dispatcher.dispatch(msg, 'client1'), 'client1') msg.cid = 20 self.assertEqual(self._dispatcher.dispatch(msg, 'client2'), 'client2') # test network host = SimpleHost() host.startup(2000) sock = NetStream() last = time.time() sock.connect('127.0.0.1', 2000) stat = 0 last = time.time() sock.nodelay(1) while 1: time.sleep(0.1) host.process() sock.process() if stat == 0: if sock.status() == conf.NET_STATE_ESTABLISHED: stat = 1 data = cPickle.dumps((stat, 'Hello, world !!'), -1) sock.send(data) last = time.time() elif stat == 1: if time.time() - last >= 2.0: stat = 2 data = cPickle.dumps((stat, 'exit'), -1) sock.send(data) event, wparam, data = host.read() if event < 0: continue if event == conf.NET_CONNECTION_DATA: client_stat, message = cPickle.loads(data) host.sendClient(wparam, 'RE: ' + message) if client_stat == 1: self.assertEqual(message, 'Hello, world !!') elif client_stat == 2: self.assertEqual(message, 'exit') host.closeClient(wparam) host.shutdown() break # test timer TimerManager.addRepeatTimer(0.15, self.addCount) last = time.time() while 1: time.sleep(0.01) TimerManager.scheduler() if time.time() - last > 1.0: break self.assertEqual(self.count, 6) return
class SimpleServer(object): def __init__(self): super(SimpleServer, self).__init__() self.entities = { constants.PLAYER_ENTITY_TYPE: {}, constants.MONSTER_ENTITY_TYPE: {}, constants.TRAP_ENTITY_TYPE: {}, constants.MISSILE_ENTITY_TYPE: {} } self.host = SimpleHost() self.dispatcher = Dispatcher() self.initDispatcher() self._start_server = False self._game_start = False self._next_entity_id = 0 self.message_queue = { constants.SEND_SINGLE: [], # (client_id, msg) constants.SEND_BROADCAST: [], # msg constants.SEND_EXCEPT: [] # (client_id, msg) } self.ready_to_delete_entities = { constants.PLAYER_ENTITY_TYPE: [], constants.MONSTER_ENTITY_TYPE: [], constants.TRAP_ENTITY_TYPE: [], constants.MISSILE_ENTITY_TYPE: [] } self.host.startup(conf.SERVER_PORT) self.game_db = game_db self.enemy_move_manager = enemy_move_module self.game_level = 0 self.during_start_game_level = False self.login_successful_clients = [] def addToLoginSuccessfulClient(self, client_id): if client_id not in self.login_successful_clients: self.login_successful_clients.append(client_id) def deleteDisconnectClient(self, client_id): if client_id in self.login_successful_clients: self.login_successful_clients.remove(client_id) def initDispatcher(self): # login and register service self.dispatcher.register(conf.LOGIN_SERVICE_ID, LoginService(conf.LOGIN_SERVICE_ID)) # handle player entity service self.dispatcher.register( conf.PLAYER_ENTITY_SERVICE_ID, PlayerEntityService(conf.PLAYER_ENTITY_SERVICE_ID)) # handle monster entity service self.dispatcher.register( conf.MONSTER_ENTITY_SERVICE_ID, MonsterEntityService(conf.MONSTER_ENTITY_SERVICE_ID)) # handle missile entity service self.dispatcher.register( conf.MISSILE_ENTITY_SERVICE_ID, MissileEntityService(conf.MISSILE_ENTITY_SERVICE_ID)) # handle trap entity service self.dispatcher.register( conf.TRAP_ENTITY_SERVICE_ID, TrapEntityService(conf.TRAP_ENTITY_SERVICE_ID)) def generateEntityID(self): self._next_entity_id += 1 return self._next_entity_id def getEntityByClientID(self, entity_type, client_id): for entity_id, entity in self.entities[entity_type].iteritems(): if entity.client_id == client_id: return entity return None def registerEntity(self, entity_type, entity): eid = self.generateEntityID() entity.entity_id = eid self.entities[entity_type][eid] = entity return self.entities[entity_type][eid] def deleteEntity(self, entity_type, entity_id): # update player msg in gameDB when player entity is ready to delete if entity_type == constants.PLAYER_ENTITY_TYPE: self.updatePlayerInGameDB( self.getEntityByID(constants.PLAYER_ENTITY_TYPE, entity_id)) # delete trap the player put # self.deletePlayerTraps(entity_id) if entity_id in self.entities[entity_type].keys(): del self.entities[entity_type][entity_id] def deletePlayerTraps(self, player_id): ready_delete_list = [] for trap_id, trap_entity in self.entities[ constants.TRAP_ENTITY_TYPE].iteritems(): if trap_entity.player_id == player_id: ready_delete_list.append(trap_id) for trap_id in ready_delete_list: # todo send trap destory msg self.deleteEntity(constants.TRAP_ENTITY_TYPE, trap_id) def updateEntity(self, entity_type, entity_id, entity): if entity_id in self.entities[entity_type].keys(): self.entities[entity_type][entity_id] = entity def updatePlayerInGameDB(self, player_entity): history_score = player_entity.history_score if player_entity.score > player_entity.history_score: history_score = player_entity.score self.game_db.player_entity_table.update_player( player_entity.name, history_score, player_entity.user_level, player_entity.ice_trap_level, player_entity.needle_trap_level, player_entity.missile_level, player_entity.exp) # send the highest score to client self.addToSingleMsgQueue( player_entity.client_id, MsgHandler.genServerMsgFromDict( conf.SERVER_HIGHEST_SCORE, {constants.HIGHEST_SCORE: history_score})) def getEntityByID(self, entity_type, entity_id): if entity_id in self.entities[entity_type].keys(): return self.entities[entity_type][entity_id] else: return None def tick(self): # receive data self.host.process() # handle msg from client event, client_id, data = self.host.read() while event >= 0: self.handleHostEvent(event, client_id, data) event, client_id, data = self.host.read() # handle entities for entity_type, entity_dict in self.entities.iteritems(): for entity_id, entity in entity_dict.iteritems(): entity.tick() # generate game level # game is started and don't in wait time and monster is all died if self._game_start and not self.during_start_game_level and \ len(self.entities[constants.MONSTER_ENTITY_TYPE]) == 0: self.during_start_game_level = True self.startGameLevel(self.game_level) self.game_level += 1 # send data self.sendQueuedMsg() self.deleteQueuedEntities() return def startGameLevel(self, level): if level < 0: level = 0 if level > len(constants.LEVELS) - 1: level = len(constants.LEVELS) - 1 wait_time = conf.LEVEL_WAIT_TIME for monster_type in constants.LEVELS[level]: TimerManager.addTimer(wait_time, self.createMonsterEntity, monster_type=monster_type) wait_time += conf.MONSTER_GEN_INTERVAL TimerManager.addTimer(wait_time - conf.MONSTER_GEN_INTERVAL, self.changeDuringGameLevel) # send to clients level time self.addToBroadcastMsgQueue( MsgHandler.genServerMsgFromDict( conf.SERVER_NEXT_LEVEL_TIME, {constants.NEXT_LEVEL_TIME: conf.LEVEL_WAIT_TIME})) def changeDuringGameLevel(self): self.during_start_game_level = not self.during_start_game_level def createMonsterEntity(self, monster_type=constants.ZOMBUNY_TYPE): # monster generate monster_entity = MonsterEntity(server=self, monster_type=monster_type) monster_loc = constants.MONSTER_GEN_LOCATION[ random.randint(0, len(constants.MONSTER_GEN_LOCATION)) - 1] monster_entity.location.setFromList(monster_loc) self.registerEntity(constants.MONSTER_ENTITY_TYPE, monster_entity) # send monster create to all the clients self.addToBroadcastMsgQueue(monster_entity.genMonsterCreateMsg()) print "generate monster {0}".format(monster_entity.entity_id) def handleHostEvent(self, event, client_id, data): if event == conf.NET_CONNECTION_NEW: print "[new connect] --> {0} client_id: {1}".format( data, client_id) dict_data = { constants.CLIENT_ID: client_id, constants.CODE: conf.COMMAND_SEND_CLIENTID, } # when new connect come, then send client_id to client send_msg = MsgHandler.genServerMsgFromDict( conf.SERVER_CLIENTID_DATA, dict_data) self.addToSingleMsgQueue(client_id, send_msg) elif event == conf.NET_CONNECTION_LEAVE: print self.entities print "[disconnect] --> {0} client_id: {1}".format(data, client_id) player_entity = self.getEntityByClientID( constants.PLAYER_ENTITY_TYPE, client_id) # maybe player is died if player_entity is not None: self.addToBroadcastMsgQueue( player_entity.genPlayerDisconnectMsg()) self.deleteEntity(constants.PLAYER_ENTITY_TYPE, player_entity.entity_id) self.deleteDisconnectClient(client_id) elif event == conf.NET_CONNECTION_DATA: # print "[receive] --> from client_id: {0} data: {1}".format(client_id, data) service_msg = ServiceMsg(*MsgHandler.get_service_id(data)) self.dispatcher.dispatch(self, service_msg, client_id) def addToSingleMsgQueue(self, client_id, send_msg): self.message_queue[constants.SEND_SINGLE].append((client_id, send_msg)) def addToBroadcastMsgQueue(self, msg): self.message_queue[constants.SEND_BROADCAST].append(msg) def addToExceptMsgQueue(self, client_id, send_msg): self.message_queue[constants.SEND_EXCEPT].append((client_id, send_msg)) def sendQueuedMsg(self): for client_id, msg in self.message_queue[constants.SEND_SINGLE]: self.host.sendClient(client_id, msg) for msg in self.message_queue[constants.SEND_BROADCAST]: for succ_id in self.login_successful_clients: self.host.sendClient(succ_id, msg) for client_id, msg in self.message_queue[constants.SEND_EXCEPT]: for succ_id in self.login_successful_clients: if succ_id == client_id: continue self.host.sendClient(succ_id, msg) self.message_queue = { constants.SEND_SINGLE: [], constants.SEND_BROADCAST: [], constants.SEND_EXCEPT: [] } # push client to send msg self.host.process() def findUserNameInPlayerEntity(self, name): for player_id, player_entity in self.entities[ constants.PLAYER_ENTITY_TYPE].iteritems(): if name == player_entity.name: return True return False def addToReadyDeleteEntities(self, entity_type, entity_id): self.ready_to_delete_entities[entity_type].append(entity_id) def deleteQueuedEntities(self): for entity_type, entity_list in self.ready_to_delete_entities.iteritems( ): for entity_id in entity_list: self.deleteEntity(entity_type, entity_id) self.ready_to_delete_entities[entity_type] = [] def genAllServerEntitiesMsg(self): return MsgHandler.genServerMsgFromDict(conf.SERVER_ALL_ENTITIES, self.getAllEntityDict()) def getAllEntityJsonData(self): return json.dumps(self.getAllEntityDict()) def getAllEntityDict(self): game_data_dict = { constants.PLAYER_ENTITIES: [ player.getDict() for entity_id, player in self.entities[ constants.PLAYER_ENTITY_TYPE].iteritems() ], constants.MONSTER_ENTITIES: [ monster.getDict() for entity_id, monster in self.entities[ constants.MONSTER_ENTITY_TYPE].iteritems() ], constants.MISSILE_ENTITIES: [ missile.getDict() for entity_id, missile in self.entities[ constants.MISSILE_ENTITY_TYPE].iteritems() ], constants.TRAP_ENTITIES: [ trap.getDict() for entity_id, trap in self.entities[ constants.TRAP_ENTITY_TYPE].iteritems() ] } return game_data_dict def startServer(self): print "starting game server..." if not self._start_server: self._start_server = True self._next_entity_id = 0 # server tick will run every 50ms TimerManager.addRepeatTimer(conf.SERVER_FRAME_TIME, self.tick) print "game server is started\n" while self._start_server: time.sleep(0.001) TimerManager.scheduler() return def stopServer(self): self._start_server = False