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