def before_request():
msg = []
msg.append("----BEGIN REQUEST----")
msg.append("Date: %s" % (datetime.datetime.now()))
msg.append("IP Address: %s" % (request.remote_addr))
msg.append("Method: %s" % (request.method))
msg.append("URL: %s" % (request.url))
if request.args is not None and len(request.args) > 0:
msg.append("Args: %s" % (request.args))
if request.json is not None:
msg.append("JSON: %s" % (request.json))
if request.form is not None and len(request.form) > 0:
msg.append("FORM: %s" % (request.form))
msg.append("----END REQUEST----\n")
log.log_debug("\n".join(msg))
if config.get_config("environment") == "PROD":
if "/static/" in request.url:
pass
else:
if "/pre_signup" not in request.url:
return redirect("/pre_signup")
g.total_messages = 0
if current_user.is_authenticated:
usr = User.get(User.uuid == current_user.uuid)
data = ContactMessage.get_user_messages(current_user.uuid)
g.total_messages = len(data)
def get_news_list(param):
ob_url = param[1]
page = param[0]
doc = pq(page)
try:
trs = doc('div.border_tr td:eq(1) tr:eq(1) tr').items()
# print(trs)
news_list = []
for tr in trs:
news = {}
# 新闻日期
date = tr('td:eq(2)').text().replace('（', '').replace('）',
'').strip()
news['date'] = date
# print(date)
# 新闻url
url = tr('td:eq(1) a').make_links_absolute(
'http://cmee.nuaa.edu.cn/').attr.href
# print(url)
news['url'] = url
# 新闻标题
title = tr('td:eq(1) a').text()
news['title'] = title
news_list.append(news)
if news_list:
log.log_debug('fetch:解析列表成功' + str(news_list))
return news_list
else:
log.log_error('fetch:新闻列表为空' + ob_url + '网站规则可能发生变化')
except:
log.log_exception('fetch:解析列表错误' + ob_url + '网站规则可能发生变化')
def playing_plot_on_event_playing_create(message_type, channel, channel_type,
serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingCreate()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家进入/退出副本事件
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_ENTER, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_plot_on_event_playing_actor_enter")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_LEAVE, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_plot_on_event_playing_actor_leave")
# 创建副本对象并加入管理器中
playing = plot_types.Playing(message.playing_, message.template_,
message.scene_)
plot_types.PlayingManager.add(playing)
log.log_debug("副本(id=%d,template=%d) 创建成功" %
(message.playing_, message.template_))
def add_award(actor, template):
log.log_debug("idol.add_award(%d, %d)" % (actor, template))
request_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.REQUEST_PROXY)
# 获取副本配置
playing_config = idol_types.Config.get(template)
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % template)
return None
# 请求增加副本奖励
request = ccrequest.playing.ttypes.RequestPlayingAddAward()
request.actor_ = actor
request.playing_template_ = template
# 奖励
request.awards_ = playing_config.get_awards()
# 抽奖
draw_awards = playing_config.get_draw_awards()
draw_awards_size = len(draw_awards)
if draw_awards_size > 0:
request.draw_award_ = draw_awards[random.randint(0, draw_awards_size - 1)]
else:
request.draw_award_ = ccentity.playing.ttypes.PlayingAwardField(ccentity.resource.ttypes.ResourceType.MIN, 0, 0)
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_ADD_AWARD, request_data, len(request_data))
def add_award(actor, template):
log.log_debug("idol.add_award(%d, %d)" % (actor, template))
request_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.REQUEST_PROXY)
# 获取副本配置
playing_config = idol_types.Config.get(template)
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % template)
return None
# 请求增加副本奖励
request = ccrequest.playing.ttypes.RequestPlayingAddAward()
request.actor_ = actor
request.playing_template_ = template
# 奖励
request.awards_ = playing_config.get_awards()
# 抽奖
draw_awards = playing_config.get_draw_awards()
draw_awards_size = len(draw_awards)
if draw_awards_size > 0:
request.draw_award_ = draw_awards[random.randint(0, draw_awards_size - 1)]
else:
request.draw_award_ = ccentity.playing.ttypes.PlayingAwardField(\
ccentity.resource.ttypes.ResourceType.MIN, 0, 0)
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_ADD_AWARD,\
request_data, len(request_data))
def generate_qmap_3d(qn, qmax, extrinsic_rotation=None, order='xyz'):
q = numpy.linspace(-qmax, qmax, qn)
Qz, Qy, Qx = numpy.meshgrid(q, q, q, indexing='ij')
qmap = numpy.zeros(shape=(qn, qn, qn, 3), dtype='float')
if order == 'xyz':
qmap[:, :, :, 0] = Qx[:, :, :]
qmap[:, :, :, 1] = Qy[:, :, :]
qmap[:, :, :, 2] = Qz[:, :, :]
elif order == 'zyx':
qmap[:, :, :, 2] = Qx[:, :, :]
qmap[:, :, :, 1] = Qy[:, :, :]
qmap[:, :, :, 0] = Qz[:, :, :]
else:
log_and_raise_error(
logger,
"order=\'%s\' is not a recognised argument for this function." %
str(order))
return
if extrinsic_rotation is not None:
log_debug(logger, "Applying qmap rotation.")
intrinsic_rotation = copy.deepcopy(extrinsic_rotation)
intrinsic_rotation.invert()
qmap = intrinsic_rotation.rotate_vectors(
qmap.ravel(), order=order).reshape(qmap.shape)
return qmap
def playing_idol_on_event_playing_actor_enter(message_type, channel,
channel_type, serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 获取请求代理
request_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.REQUEST_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家杀死NPC事件、角色被杀死事件
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_idol_on_event_actor_kill_npc")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_idol_on_event_actor_killed")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_REQUEST_COMPLETE,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_idol_on_event_playing_actor_request_complete")
# 获取副本对象
playing = idol_types.PlayingManager.get(message.playing_)
if playing == None:
log.log_error("idol副本 获取 playing(%d) 失败" % message.playing_)
return None
now = time.time()
# 获取玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
# 玩家不存在时，创建并加入副本管理器中
actor = idol_types.Actor(message.actor_, now)
playing.add_actor(actor)
# 副本管理器中加入一个玩家ID到副本ID的对应关系
idol_types.PlayingManager.add_actor(message.actor_, message.playing_)
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - actor.get_start_time()
request.scores_ = []
request.datas_ = []
# 序列化消息
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR, \
request_data, len(request_data))
log.log_debug("玩家(%d) 进入 idol副本(id=%d,template=%d)" % \
(message.actor_, message.playing_, message.template_))
def playing_idol_on_event_playing_create(message_type, channel, channel_type, serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingCreate()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家进入/退出副本事件
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_ENTER, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_idol_on_event_playing_actor_enter")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_LEAVE, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_idol_on_event_playing_actor_leave")
# 创建副本对象并加入管理器中
playing = idol_types.Playing(message.playing_, message.template_, message.scene_)
idol_types.PlayingManager.add(playing)
# 获取副本配置
playing_config = idol_types.Config.get(message.template_)
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % message.template_)
return None
# 召唤一个BOSS
facade_request.summon_npc(message.scene_, playing_config.get_pass_kill_npc(),\
playing_config.get_pass_npc_x(), playing_config.get_pass_npc_y());
log.log_debug("idol副本(id=%d,template=%d) 创建成功" % (message.playing_, message.template_))
def get_th_crossed_proc():
try:
query = """
SELECT
a.id, a.request, time_to_sec(TIMEDIFF(now(),a.start_time))/60 as DIFF, b.th, a.status, b.script
FROM
procmon.request_queue a, procmon.request_to_process b
WHERE
(a.status = 'Starting' OR a.status = 'Running')
AND
(a.request = b.request_token)
HAVING
DIFF > b.th
"""
mysqlCursor.execute(query)
if mysqlCursor.rowcount > 0:
return mysqlCursor.fetchall()
else:
return []
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in get_th_crossed_proc()", 1, -6)
def playing_idol_on_event_playing_actor_leave(message_type, channel, channel_type, serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorLeave()
# 反序列化
TSerialization.deserialize(message, serialize)
# 取消关注玩家杀死NPC事件、角色被杀死事件
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_idol_on_event_actor_killed")
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_idol_on_event_actor_kill_npc")
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_REQUEST_COMPLETE,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_idol_on_event_playing_actor_request_complete")
# 副本管理器中删除玩家对象
idol_types.PlayingManager.remove_actor(message.actor_)
log.log_debug("玩家(%d) 离开 idol副本(id=%d,template=%d)" % \
(message.actor_, message.playing_, message.template_))
def playing_plot_on_event_actor_killed(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.role.ttypes.EventRoleKilled()
# 消息反序列化
TSerialization.deserialize(message, serialize)
# 主角类型只能是玩家
if message.type_ != ccentity.entity.ttypes.EntityType.TYPE_ACTOR:
return None
# 根据玩家ID获取所在副本ID
playing_id = plot_types.PlayingManager.get_actor_playing(message.id_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("plot_types.PlayingManager.get_actor_playing(%d) failed." % message.id_)
return None
# 获取副本对象
playing = plot_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("plot_types.PlayingManager.get(%d) failed." % playing_id)
return None
# 获取玩家对象
actor = playing.get_actor(message.id_)
if actor == None:
proxy.Logging.error("playing.get_actor(%d) failed." % message.id_)
return None
# 玩家死亡次数增加
actor.inc_dead_count(1)
log.log_debug("玩家(%d) 死亡次数(%d)" % (message.id_, actor.get_dead_count()))
def check_runtime():
try:
proc_list = utility.get_th_crossed_proc()
for proc in proc_list:
r_id = proc[0]
req_str = proc[1].strip()
diff = proc[2]
th = proc[3]
status = proc[4]
script = proc[5]
status = status + '..TH Crossed'
utility.update_status(status, r_id)
msgBody = "Request:" + req_str + ", " + "ID:" + str(r_id) + ", " + "Script:" + script + "\n"
msgBody += "Runtime TH: " + str(th) + " min" + "\n" + "\n"
msgBody += "Total time taken by the process upto now: " + str(diff) + " min" + "\n"
msgBody += "Runtime has crossed the TH value."
email_sender.send(r_id, req_str, msgBody)
except Exception as err:
log.log_debug(err, 1, -4)
log.log_debug("Error in check_runtime()", 1, -4)
def add_award(actor, template, score):
log.log_debug("plot.add_award(%d, %d, %d)" % (actor, template, score))
playing_config = plot_types.Config.get(template)
if playing_config == None:
log.log_error("找不到日常副本配置(%d)" % template)
return None
request = ccrequest.playing.ttypes.RequestPlayingAddAward()
request.actor_ = actor
request.playing_template_ = template
award_field = ccentity.playing.ttypes.PlayingAwardField()
award_field.type_ = ccentity.resource.ttypes.ResourceType.RESOURCE
request.awards_ = []
# 奖励
award_field.type_ = ccentity.resource.ttypes.ResourceType.ITEM
for i in playing_config.get_awards():
request.awards_.append(i)
# 抽奖奖励
draw_items = playing_config.get_draw_items()
draw_items_size = len(draw_items)
if draw_items_size > 0:
request.draw_award_ = ccentity.playing.ttypes.PlayingAwardField(
ccentity.resource.ttypes.ResourceType.ITEM, draw_items[random.randint(0, draw_items_size - 1)], 1
)
if proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_ADD_AWARD, request) == False:
proxy.Logging.error("发送请求 REQUEST_PLAYING_ADD_AWARD 出错")
return None
proxy.Logging.debug("增加奖励(玩家=%d) 成功" % actor)
def update_db_lock(status, name, flag):
try:
#mysqlCursor.execute("""
# UPDATE procmon.users
# SET status=%s
# WHERE name=%s
# """, (status, name))
if flag == 'start':
mysqlCursor.execute("""
UPDATE procmon.users
SET status=%s, start_time=now()
WHERE name=%s
""", (status, name))
elif flag == 'end':
mysqlCursor.execute("""
UPDATE procmon.users
SET status=%s, end_time=now()
WHERE name=%s
""", (status, name))
mysqlConn.commit()
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in update_db_lock()", 1, -6)
mysqlConn.rollbak()
def playing_plot_on_event_playing_actor_leave(message_type, channel,
channel_type, serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorLeave()
# 反序列化
TSerialization.deserialize(message, serialize)
# 取消关注玩家杀死NPC事件、请求完成副本事件、角色被杀死事件
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_plot_on_event_actor_killed")
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_REQUEST_COMPLETE,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_plot_on_event_playing_actor_request_complete")
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_plot_on_event_actor_kill_npc")
# 副本1需要关注玩家血量改变的事件
if message.template_ == 1:
proxy.Communicator.unfollow(ccevent.ttypes.EventType.EVENT_ROLE_CHANGE_HP, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_plot_on_event_role_change_hp")
# 副本管理器中删除玩家对象
plot_types.PlayingManager.remove_actor(message.actor_)
log.log_debug("玩家(%d)离开副本(id=%d,template=%d)" % \
(message.actor_, message.playing_, message.template_))
def _check_dep(path):
if os.path.isfile(path):
with open(path) as file_dependency:
lines = file_dependency.readlines()
for line in lines:
try:
package_version = ''
installer_name = ''
res = []
for str_equal in line.split('='):
if str_equal.strip(): # not blank
for str_blank in str_equal.split():
res.append(str_blank)
if len(res) % 2 == 0:
if len(res):
log_err('util', 'failed to check dependency, invalid format' )
return False
continue # if it is blank, then continue
else:
package_name = res[0]
for index_to_match in range(1, len(res), 2):
if res[index_to_match] == 'installer':
installer_name = res[index_to_match + 1]
continue
if res[index_to_match] == 'version':
package_version = res[index_to_match + 1]
continue
if installer_name == '':
installers = ['pip', 'apt-get']
for installer in installers:
installer_name = installer
if package_version == '':
cmd = '%s install %s' % (str(installer_name), str(package_name))
else :
cmd = '%s install %s==%s' % (str(installer_name), str(package_name), str(package_version))
status, output = commands.getstatusoutput(cmd)
if status == 0:
log_debug('util', 'check dependency, finished installing %s' % str(package_name))
break
if status != 0:
log_err('util', 'check dependency, invalid installer, failed to install %s' % str(package_name))
return False
else:
if package_version == '':
cmd = '%s install %s' % (str(installer_name), str(package_name))
else:
cmd = '%s install %s==%s' % (str(installer_name), str(package_name), str(package_version))
status, output = commands.getstatusoutput(cmd)
if status == 0:
log_debug('util', 'check dependency, finished installing %s' % str(package_name))
else:
log_err('util', 'check dependency, failed to install %s' % str(package_name))
return False
except:
continue # if it is blank, continue. else return False
return True
def running_proc():
try:
query = "SELECT count(request) FROM procmon.request_queue WHERE status = 'Running'"
mysqlCursor.execute(query)
return mysqlCursor.rowcount
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in running_proc()", 1, -6)
def playing_idol_on_event_playing_actor_enter(message_type, channel, channel_type, serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 获取请求代理
request_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.REQUEST_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家杀死NPC事件、角色被杀死事件
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_idol_on_event_actor_kill_npc")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_idol_on_event_actor_killed")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_REQUEST_COMPLETE,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_idol_on_event_playing_actor_request_complete")
# 获取副本对象
playing = idol_types.PlayingManager.get(message.playing_)
if playing == None:
log.log_error("idol副本 获取 playing(%d) 失败" % message.playing_)
return None
now = time.time()
# 获取玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
# 玩家不存在时，创建并加入副本管理器中
actor = idol_types.Actor(message.actor_, now)
playing.add_actor(actor)
# 副本管理器中加入一个玩家ID到副本ID的对应关系
idol_types.PlayingManager.add_actor(message.actor_, message.playing_)
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - actor.get_start_time()
request.scores_ = []
request.datas_ = []
# 序列化消息
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR, \
request_data, len(request_data))
log.log_debug("玩家(%d) 进入 idol副本(id=%d,template=%d)" % \
(message.actor_, message.playing_, message.template_))
def playing_idol_on_event_actor_killed(message_type, channel, channel_type,
serialize):
# 事件消息
message = ccevent.role.ttypes.EventRoleKilled()
# 消息反序列化
TSerialization.deserialize(message, serialize)
# 主角类型只能是玩家
if message.type_ != ccentity.entity.ttypes.EntityType.TYPE_ACTOR:
return None
# 根据玩家ID获取所在副本ID
playing_id = idol_types.PlayingManager.get_actor_playing(message.id_)
if playing_id == None or playing_id == 0:
return None
# 获取副本对象
playing = idol_types.PlayingManager.get(playing_id)
if playing == None:
return None
# 获取玩家对象
actor = playing.get_actor(message.id_)
if actor == None:
return None
# 玩家死亡次数增加
actor.inc_dead_count()
log.log_debug("idol副本 玩家(%d) 死亡次数(%d)" %
(message.id_, actor.get_dead_count()))
# 获取请求代理
request_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.REQUEST_PROXY)
# 先复活玩家
request = ccrequest.scene.ttypes.RequestSceneRevive()
request.actor_ = message.id_
request.stay_revive_ = True
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_SCENE_REVIVE, \
request_data, len(request_data))
# 请求失败消息
request = ccrequest.playing.ttypes.RequestPlayingFailure()
request.playing_ = playing_id
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_FAILURE, \
request_data, len(request_data))
log.log_debug("idol副本 玩家(%d) 失败" % message.id_)
def call(command):
"""Call into the system and run Command (string)"""
s = time.time()
cmd = join_and_sanitize(command)
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
result, _err = proc.communicate()
e = time.time()
log_debug(["subprocess command:", cmd])
log_debug(["subprocess time:", (e - s)])
return result
def generate_qmap(X,
Y,
pixel_size,
detector_distance,
wavelength,
extrinsic_rotation=None,
order="xyz"):
r"""
Generate scattering vector map from experimental parameters
Args:
:X (array): :math:`x`-coordinates of pixels in unit meter
:Y (array): :math:`y`-coordinates of pixels in unit meter
:pixel_size (float): Pixel size (i.e. edge length) in unit meter
:detector_distance (float): Distance from interaction point to detector plane
:wavelength (float): Photon wavelength in unit meter
Kwargs:
:extrinsic_rotation (:class:`condor.utils.rotation.Rotation`): Extrinsic rotation of the sample. If ``None`` no rotation is applied (default ``None``)
:order (str): Order of scattering vector coordinates in the output array. Choose either ``'xyz'`` or ``'zyx'`` (default ``'xyz'``)
"""
log_debug(logger,
"Allocating qmap (%i,%i,%i)" % (X.shape[0], X.shape[1], 3))
R_Ewald = 2 * numpy.pi / wavelength
p_x = X * pixel_size
p_y = Y * pixel_size
p_z = numpy.ones_like(X) * detector_distance
l = numpy.sqrt(p_x**2 + p_y**2 + p_z**2)
r_x = p_x / l
r_y = p_y / l
r_z = p_z / l - 1.
qmap = numpy.zeros(shape=(X.shape[0], X.shape[1], 3))
if order == "xyz":
qmap[:, :, 0] = r_x * R_Ewald
qmap[:, :, 1] = r_y * R_Ewald
qmap[:, :, 2] = r_z * R_Ewald
elif order == "zyx":
qmap[:, :, 0] = r_z * R_Ewald
qmap[:, :, 1] = r_y * R_Ewald
qmap[:, :, 2] = r_x * R_Ewald
else:
log_and_raise_error(logger,
"Indexing with order=%s is invalid." % order)
if extrinsic_rotation is not None:
log_debug(logger, "Applying qmap rotation.")
intrinsic_rotation = copy.deepcopy(extrinsic_rotation)
intrinsic_rotation.invert()
qmap = intrinsic_rotation.rotate_vectors(
qmap.ravel(), order=order).reshape(qmap.shape)
return qmap
def playing_idol_on_event_actor_killed(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.role.ttypes.EventRoleKilled()
# 消息反序列化
TSerialization.deserialize(message, serialize)
# 主角类型只能是玩家
if message.type_ != ccentity.entity.ttypes.EntityType.TYPE_ACTOR:
return None
# 根据玩家ID获取所在副本ID
playing_id = idol_types.PlayingManager.get_actor_playing(message.id_)
if playing_id == None or playing_id == 0:
return None
# 获取副本对象
playing = idol_types.PlayingManager.get(playing_id)
if playing == None:
return None
# 获取玩家对象
actor = playing.get_actor(message.id_)
if actor == None:
return None
# 玩家死亡次数增加
actor.inc_dead_count()
log.log_debug("idol副本 玩家(%d) 死亡次数(%d)" % (message.id_, actor.get_dead_count()))
# 获取请求代理
request_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.REQUEST_PROXY)
# 先复活玩家
request = ccrequest.scene.ttypes.RequestSceneRevive()
request.actor_ = message.id_
request.stay_revive_ = True
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_SCENE_REVIVE, \
request_data, len(request_data))
# 请求失败消息
request = ccrequest.playing.ttypes.RequestPlayingFailure()
request.playing_ = playing_id
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_FAILURE, \
request_data, len(request_data))
log.log_debug("idol副本 玩家(%d) 失败" % message.id_)
def resize_horizontal(self, increment):
if not self.parent.resize_horizontal(self, increment):
log_debug(['Unable to resize. Using alternative'])
next_child = self.parent.find_earliest_a_but_not_me(self)
if next_child is not None:
if not self.parent.all_are_bees(self):
log_debug(['All are not bees'])
increment *= -1
elif self.parent.get_plane_type() == PLANE.VERTICAL:
increment *= -1
next_child.resize_horizontal(increment)
def db_lock():
try:
query = "SELECT name FROM procmon.users WHERE status='active' AND time_to_sec(TIMEDIFF(now(), start_time))/60 < 5"
mysqlCursor.execute(query)
if mysqlCursor.rowcount > 0:
return True
else:
return False
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in db_lock()", 1, -6)
def _shrink_stacks(self, group_prefix="/"):
for k in self._f[group_prefix].keys():
name = group_prefix + k
if isinstance(self._f[name], h5py.Dataset):
log.log_debug(logger, "Shrinking dataset %s to stack length %i" % (name, self._i))
s = list(self._f[name].shape)
s.pop(0)
s.insert(0, self._i)
s = tuple(s)
self._f[name].resize(s)
else:
self._shrink_stacks(name + "/")
def resize_vertical(self, increment):
"""Request parent to resize window."""
if not self.parent.resize_vertical(self, increment):
log_debug(['Unable to resize. Using alternative'])
next_child = self.parent.find_earliest_a_but_not_me(self)
if next_child is not None:
if not self.parent.all_are_bees(self):
log_debug(['All are not bees'])
increment *= -1
elif self.parent.get_plane_type() == PLANE.HORIZONTAL:
increment *= -1
next_child.resize_vertical(increment)
def fetch_map(emd_id):
url = "ftp://ftp.ebi.ac.uk/pub/databases/emdb/structures/EMD-%s/map/emd_%s.map.gz" % (str(emd_id),str(emd_id))
log.log_debug(logger, "Downloading file for EMDID %s from URL %s" % (emd_id, url))
filename = "./emd_%s.map" % str(emd_id)
response = urllib2.urlopen(url)
compressedFile = StringIO.StringIO()
compressedFile.write(response.read())
compressedFile.seek(0)
decompressedFile = gzip.GzipFile(fileobj=compressedFile, mode='rb')
log.log_debug(logger, "Download of %s ended." % (filename))
with open(filename, 'w') as outfile:
outfile.write(decompressedFile.read())
return read_map(filename)
def get_new_requests():
try:
query = "SELECT id, request, args FROM procmon.request_queue WHERE status is NULL or status=''"
mysqlCursor.execute(query)
if mysqlCursor.rowcount > 0:
return mysqlCursor.fetchall()
else:
return []
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in get_new_requests()", 1, -6)
def update_status(flag, id):
try:
mysqlCursor.execute("""
UPDATE procmon.request_queue
SET status=%s
WHERE id=%s
""", (flag, id))
mysqlConn.commit()
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in update_status()", 1, -6)
mysqlConn.rollback()
def get_single_running_proc():
try:
query = "SELECT id, request_token, args FROM procmon.request_to_process WHERE status=1 AND timer=0"
mysqlCursor.execute(query)
if mysqlCursor.rowcount > 0:
return mysqlCursor.fetchall()
else:
return []
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in get_single_running_proc()", 1, -6)
def fetch_map(emd_id):
url = "ftp://ftp.ebi.ac.uk/pub/databases/emdb/structures/EMD-%s/map/emd_%s.map.gz" % (str(emd_id),str(emd_id))
log.log_debug(logger, "Downloading file for EMDID %s from URL %s" % (emd_id, url))
filename = "./emd_%s.map" % str(emd_id)
response = urllib2.urlopen(url)
compressedFile = StringIO.StringIO()
compressedFile.write(response.read())
compressedFile.seek(0)
decompressedFile = gzip.GzipFile(fileobj=compressedFile, mode='rb')
log.log_debug(logger, "Download of %s ended." % (filename))
with open(filename, 'w') as outfile:
outfile.write(decompressedFile.read())
return read_map(filename)
def playing_plot_on_event_actor_kill_npc(message_type, channel, channel_type,
serialize):
# 获取请求代理
request_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.REQUEST_PROXY)
# 事件消息
message = ccevent.actor.ttypes.EventActorKillNpc()
# 反序列化
TSerialization.deserialize(message, serialize)
# 获取玩家所在副本ID
playing_id = plot_types.PlayingManager.get_actor_playing(message.actor_)
if playing_id == None or playing_id == 0:
proxy.Logging.error(
"plot_types.PlayingManager.get_actor_playing(%d) failed." %
message.actor_)
return None
# 获取副本对象
playing = plot_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("plot_types.PlayingManager.get(%d) failed." %
playing_id)
return None
# 获取副本玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("playing.get_actor(%d) failed." % message.actor_)
return None
# 增加杀死NPC个数
actor.inc_kill_npc(message.npc_template_)
# 请求消息
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeScore()
# 玩家ID
request.actor_ = message.actor_
# 分数对象(得分类型=杀死NPC, key=NPC模板ID, value=当前杀死的个数)
score_field = ccentity.playing.ttypes.PlayingScoreField(ccentity.playing.ttypes.PlayingScoreType.KILL_NPC, \
message.npc_template_, actor.get_kill_npc(message.npc_template_))
request.score_ = score_field
# 序列化消息
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_SCORE, \
request_data, len(request_data))
log.log_debug("玩家(%d) 杀死 NPC(%d) 个数(%d)" % (message.actor_, score_field.key_, \
score_field.value_))
def _write_without_iterate(self, D, group_prefix="/"):
for k in D.keys():
if isinstance(D[k],dict):
group_prefix_new = group_prefix + k + "/"
log.log_debug(logger, "Writing group %s" % group_prefix_new)
if k not in self._f[group_prefix]:
self._f.create_group(group_prefix_new)
self._write_without_iterate(D[k], group_prefix_new)
else:
name = group_prefix + k
log.log_debug(logger, "Writing dataset %s" % name)
data = D[k]
if k not in self._f[group_prefix]:
if numpy.isscalar(data):
maxshape = (None,)
shape = (self._chunksize,)
dtype = numpy.dtype(type(data))
if dtype == "S":
dtype = h5py.new_vlen(str)
axes = "experiment_identifier:value"
else:
data = numpy.asarray(data)
try:
h5py.h5t.py_create(data.dtype, logical=1)
except TypeError:
log.log_warning(logger, "Could not save dataset %s. Conversion to numpy array failed" % name)
continue
maxshape = tuple([None]+list(data.shape))
shape = tuple([self._chunksize]+list(data.shape))
dtype = data.dtype
ndim = data.ndim
axes = "experiment_identifier"
if ndim == 1: axes = axes + ":x"
elif ndim == 2: axes = axes + ":y:x"
elif ndim == 3: axes = axes + ":z:y:x"
log.log_debug(logger, "Create dataset %s [shape=%s, dtype=%s]" % (name,str(shape),str(dtype)))
self._f.create_dataset(name, shape, maxshape=maxshape, dtype=dtype, **self._create_dataset_kwargs)
self._f[name].attrs.modify("axes",[axes])
if self._f[name].shape[0] <= self._i:
if numpy.isscalar(data):
data_shape = []
else:
data_shape = data.shape
new_shape = tuple([self._chunksize*(self._i/self._chunksize+1)]+list(data_shape))
log.log_debug(logger, "Resize dataset %s [old shape: %s, new shape: %s]" % (name,str(self._f[name].shape),str(new_shape)))
self._f[name].resize(new_shape)
log.log_debug(logger, "Write to dataset %s at stack position %i" % (name, self._i))
if numpy.isscalar(data):
self._f[name][self._i] = data
else:
self._f[name][self._i,:] = data[:]
def get_host_script_user_pass(req_str):
try:
query = "SELECT host, port, script, username, password FROM procmon.request_to_process WHERE request_token='" + req_str + "'"
mysqlCursor.execute(query)
res = mysqlCursor.fetchone()
if res != None:
return res[0].strip(), res[1], res[2].strip(), res[3].strip(), res[4].strip()
else:
return None, None, None, None, None
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in get_host_script_user_pass()", 1, -6)
def get_contact_list(req_str):
try:
query = "SELECT contacts FROM procmon.request_to_process WHERE request_token='" + req_str + "'"
mysqlCursor.execute(query)
res = mysqlCursor.fetchone()
if(res!=None):
return res[0].strip()
else:
return config.from_addr
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in get_contact_list()", 1, -6)
def insert_to_queue(request_name, arguments):
try:
mysqlCursor.execute("""
INSERT INTO procmon.request_queue(request, args)
VALUES(%s, %s)
""", (request_name, arguments)
)
mysqlConn.commit()
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in insert_to_queue()", 1, -6)
mysqlConn.rollback()
def get_cmd(ext):
try:
query = "SELECT cmd FROM procmon.cmd_format WHERE file_ext = '" + ext.strip() + "'"
mysqlCursor.execute(query)
#return mysqlCursor.fetchone()[0]
cmd = mysqlCursor.fetchone()
if cmd != None:
return cmd[0]
else:
return cmd
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in get_cmd()", 1, -6)
def disable_proc(id, pname, status):
try:
mysqlCursor.execute("""
UPDATE procmon.request_to_process
SET status = %s
WHERE id = %s
""", (status, id)
)
mysqlConn.commit()
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in disable_proc()", 1, -6)
mysqlConn.rollback()
def update_next_runtime(id):
try:
mysqlCursor.execute("""
UPDATE procmon.request_to_process
SET next_run_time = DATE_ADD(NOW(), INTERVAL timer SECOND)
WHERE id = %s
""", (id)
)
mysqlConn.commit()
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in update_next_runtime()", 1, -6)
mysqlConn.rollback()
def connect():
i = 0
while i < config.max_attempts:
try:
global mysqlConn
global mysqlCursor
mysqlConn = MySQLdb.connect(host=config.DB_HOST, port=config.DB_PORT, user=config.DB_USER, passwd=config.DB_PASS)
mysqlCursor = mysqlConn.cursor()
break
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in connecting MySQL DB..Trying again", 1, -6)
i += 1
time.sleep(2)
def generate_qmap(X,Y,pixel_size,detector_distance,wavelength,extrinsic_rotation=None, order="xyz"):
r"""
Generate scattering vector map from experimental parameters
Args:
:X (array): :math:`x`-coordinates of pixels in unit meter
:Y (array): :math:`y`-coordinates of pixels in unit meter
:pixel_size (float): Pixel size (i.e. edge length) in unit meter
:detector_distance (float): Distance from interaction point to detector plane
:wavelength (float): Photon wavelength in unit meter
Kwargs:
:extrinsic_rotation (:class:`condor.utils.rotation.Rotation`): Extrinsic rotation of the sample. If ``None`` no rotation is applied (default ``None``)
:order (str): Order of scattering vector coordinates in the output array. Choose either ``'xyz'`` or ``'zyx'`` (default ``'xyz'``)
"""
log_debug(logger, "Allocating qmap (%i,%i,%i)" % (X.shape[0],X.shape[1],3))
R_Ewald = 2*numpy.pi/wavelength
p_x = X*pixel_size
p_y = Y*pixel_size
p_z = numpy.ones_like(X)*detector_distance
l = numpy.sqrt(p_x**2+p_y**2+p_z**2)
r_x = p_x/l
r_y = p_y/l
r_z = p_z/l - 1.
qmap = numpy.zeros(shape=(X.shape[0],X.shape[1],3))
if order == "xyz":
qmap[:,:,0] = r_x * R_Ewald
qmap[:,:,1] = r_y * R_Ewald
qmap[:,:,2] = r_z * R_Ewald
elif order == "zyx":
qmap[:,:,0] = r_z * R_Ewald
qmap[:,:,1] = r_y * R_Ewald
qmap[:,:,2] = r_x * R_Ewald
else:
log_and_raise_error(logger, "Indexing with order=%s is invalid." % order)
if extrinsic_rotation is not None:
log_debug(logger, "Applying qmap rotation.")
intrinsic_rotation = copy.deepcopy(extrinsic_rotation)
intrinsic_rotation.invert()
qmap = intrinsic_rotation.rotate_vectors(qmap.ravel(), order=order).reshape(qmap.shape)
return qmap
def playing_plot_on_event_actor_kill_npc(message_type, channel, channel_type, serialize):
# 获取请求代理
request_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.REQUEST_PROXY)
# 事件消息
message = ccevent.actor.ttypes.EventActorKillNpc()
# 反序列化
TSerialization.deserialize(message, serialize)
# 获取玩家所在副本ID
playing_id = plot_types.PlayingManager.get_actor_playing(message.actor_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("plot_types.PlayingManager.get_actor_playing(%d) failed." % message.actor_)
return None
# 获取副本对象
playing = plot_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("plot_types.PlayingManager.get(%d) failed." % playing_id)
return None
# 获取副本玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("playing.get_actor(%d) failed." % message.actor_)
return None
# 增加杀死NPC个数
actor.inc_kill_npc(message.npc_template_)
# 请求消息
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeScore()
# 玩家ID
request.actor_ = message.actor_
# 分数对象(得分类型=杀死NPC, key=NPC模板ID, value=当前杀死的个数)
score_field = ccentity.playing.ttypes.PlayingScoreField(ccentity.playing.ttypes.PlayingScoreType.KILL_NPC, \
message.npc_template_, actor.get_kill_npc(message.npc_template_))
request.score_ = score_field
# 序列化消息
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_SCORE, \
request_data, len(request_data))
log.log_debug("玩家(%d) 杀死 NPC(%d) 个数(%d)" % (message.actor_, score_field.key_, \
score_field.value_))
def get_periodic_running_proc():
try:
query = """
SELECT id, request_token, args, entry_time, next_run_time, timer FROM procmon.request_to_process
WHERE
( status = 1 AND timer > 0 )
AND
( next_run_time IS NULL OR ( NOW() - next_run_time ) >= 0 )
"""
mysqlCursor.execute(query)
if mysqlCursor.rowcount > 0:
return mysqlCursor.fetchall()
else:
return []
except Exception as err:
log.log_debug(err, 1, -6)
log.log_debug("Error in get_single_running_proc()", 1, -6)
def playing_idol_on_event_playing_destory(message_type, channel, channel_type, serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingDestory()
# 反序列化
TSerialization.deserialize(message, serialize)
# 取消关注玩家进入/退出副本
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_ENTER, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_idol_on_event_playing_actor_enter")
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_LEAVE, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_idol_on_event_playing_actor_leave")
# 从管理器中删除副本对象
idol_types.PlayingManager.remove(message.playing_)
log.log_debug("副本(%d) 销毁成功" % message.playing_)
def make_icosahedron_map(N, nRmax, extrinsic_rotation=None):
"""
Generate map of a uniform icosahedron (density = 1) on a regular grid
Orientation: The cartesian grid axis all lie parallel to 2-fold symmetry axes of the icosahedron.
Args:
:N (int): Edge length of the grid in unit pixels
:nRmax (float): Outer radius of the icosahedron in unit pixels
Kwargs:
:rotation (:class:`condor.utils.rotation.Rotation`): Rotation instance for extrinsic rotation of the icosahedron.
"""
log_debug(logger, "Building icosahedral geometry")
log_debug(logger, "Grid: %i x %i x %i (%i voxels)" % (N, N, N, N**3))
t0 = time.time()
if extrinsic_rotation is not None:
q = extrinsic_rotation.get_as_quaternion()
icomap = icosahedron.icosahedron(N, nRmax, q)
else:
icomap = icosahedron.icosahedron(N, nRmax)
t1 = time.time()
log_debug(logger, "Built map within %f seconds." % (t1 - t0))
return icomap
def make_icosahedron_map_slow(N, nRmax, extrinsic_rotation=None):
"""
Generate map of a uniform icosahedron (density = 1) on a regular grid (*slow python implementation*)
Orientation: The cartesian grid axis all lie parallel to 2-fold symmetry axes of the icosahedron.
Args:
:N (int): Edge length of the grid in unit pixels
:nRmax (float): Outer radius of the icosahedron in unit pixels
Kwargs:
:rotation (:class:`condor.utils.rotation.Rotation`): Rotation instance for extrinsic rotation of the icosahedron.
"""
na = nRmax / numpy.sqrt(10.0 + 2 * numpy.sqrt(5)) * 4.
nRmin = numpy.sqrt(3) / 12 * (3.0 + numpy.sqrt(5)) * na # radius at faces
log_debug(logger, "Building icosahedral geometry")
n_list = get_icosahedron_normal_vectors()
# Rotate
if extrinsic_rotation is not None:
n_list = extrinsic_rotation.rotate_vectors(numpy.array(n_list))
X, Y, Z = 1.0 * numpy.mgrid[0:N, 0:N, 0:N]
X = X - (N - 1) / 2.
Y = Y - (N - 1) / 2.
Z = Z - (N - 1) / 2.
log_debug(logger, "Grid: %i x %i x %i (%i voxels)" % (N, N, N, N**3))
icomap = numpy.zeros((len(n_list), N, N, N))
# calculate distance of all voxels to all faces (negative inside, positive outside icosahedron)
for i in range(len(n_list)):
icomap[i, :, :, :] = (X * n_list[i][0] + Y * n_list[i][1] +
Z * n_list[i][2]) + nRmin
s = 1.
M = icomap.copy()
temp = abs(M) < 0.5 * s
icomap[temp] = 0.5 + icomap[temp] / s
icomap[M < (-0.5) * s] = 0
icomap[M > 0.5 * s] = 1
icomap = icomap.min(0)
return icomap
def playing_plot_on_event_playing_destory(message_type, channel, channel_type,
serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingDestory()
# 反序列化
TSerialization.deserialize(message, serialize)
# 取消关注玩家进入/退出副本
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_ENTER, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_plot_on_event_playing_actor_enter")
communicator_proxy.unfollow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_LEAVE, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_plot_on_event_playing_actor_leave")
# 从管理器中删除副本对象
plot_types.PlayingManager.remove(message.playing_)
log.log_debug("副本(%d) 销毁成功" % message.playing_)
def playing_plot_on_event_actor_killed(message_type, channel, channel_type,
serialize):
# 事件消息
message = ccevent.role.ttypes.EventRoleKilled()
# 消息反序列化
TSerialization.deserialize(message, serialize)
# 主角类型只能是玩家
if message.type_ != ccentity.entity.ttypes.EntityType.TYPE_ACTOR:
return None
# 根据玩家ID获取所在副本ID
playing_id = plot_types.PlayingManager.get_actor_playing(message.id_)
if playing_id == None or playing_id == 0:
proxy.Logging.error(
"plot_types.PlayingManager.get_actor_playing(%d) failed." %
message.id_)
return None
# 获取副本对象
playing = plot_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("plot_types.PlayingManager.get(%d) failed." %
playing_id)
return None
# 获取玩家对象
actor = playing.get_actor(message.id_)
if actor == None:
proxy.Logging.error("playing.get_actor(%d) failed." % message.id_)
return None
# 玩家死亡次数增加
actor.inc_dead_count(1)
log.log_debug("玩家(%d) 死亡次数(%d)" % (message.id_, actor.get_dead_count()))
def add_award(actor, template, score):
log.log_debug("plot.add_award(%d, %d, %d)" % (actor, template, score))
playing_config = plot_types.Config.get(template)
if playing_config == None:
log.log_error("找不到日常副本配置(%d)" % template)
return None
request = ccrequest.playing.ttypes.RequestPlayingAddAward()
request.actor_ = actor
request.playing_template_ = template
award_field = ccentity.playing.ttypes.PlayingAwardField()
award_field.type_ = ccentity.resource.ttypes.ResourceType.RESOURCE
request.awards_ = []
# 奖励
award_field.type_ = ccentity.resource.ttypes.ResourceType.ITEM
for i in playing_config.get_awards():
request.awards_.append(i)
# 抽奖奖励
draw_items = playing_config.get_draw_items()
draw_items_size = len(draw_items)
if draw_items_size > 0:
request.draw_award_ = ccentity.playing.ttypes.PlayingAwardField( \
ccentity.resource.ttypes.ResourceType.ITEM, \
draw_items[random.randint(0, draw_items_size - 1)], 1)
if proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_ADD_AWARD,\
request) == False:
proxy.Logging.error("发送请求 REQUEST_PLAYING_ADD_AWARD 出错")
return None
proxy.Logging.debug("增加奖励(玩家=%d) 成功" % actor)
def playing_idol_on_event_playing_create(message_type, channel, channel_type,
serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingCreate()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家进入/退出副本事件
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_ENTER, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_idol_on_event_playing_actor_enter")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_LEAVE, \
message.template_, ccevent.ttypes.ChannelType.CHANNEL_PLAYING, \
"playing_idol_on_event_playing_actor_leave")
# 创建副本对象并加入管理器中
playing = idol_types.Playing(message.playing_, message.template_,
message.scene_)
idol_types.PlayingManager.add(playing)
# 获取副本配置
playing_config = idol_types.Config.get(message.template_)
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % message.template_)
return None
# 召唤一个BOSS
facade_request.summon_npc(message.scene_, playing_config.get_pass_kill_npc(),\
playing_config.get_pass_npc_x(), playing_config.get_pass_npc_y())
log.log_debug("idol副本(id=%d,template=%d) 创建成功" %
(message.playing_, message.template_))
def handler(wsock, message):
d = dictionary[str(wsock)]
log_debug(dictionary.keys())
log_debug(d["size"])
try:
obj = json.loads(message)
print(obj)
if obj["action"] == "startUploading":
d["file_size"] = obj.get("fileSize", 0)
d["name"] = obj.get("name", "")
d["description"] = obj.get("description", "")
elif obj["action"] == "getDataList":
offset = obj.get("offset", 0)
limit = obj.get("limit")
res = fm.get_data_list()
res["action"] = obj["action"]
wsock.send(json.dumps(res))
elif obj["action"] == "getData":
offset = obj.get("offset", 0)
limit = obj.get("limit", 10)
data_id = obj.get("dataId")
res = fm.get_data(data_id, offset, limit)
res["action"] = obj["action"]
res["dataId"] = data_id
wsock.send(json.dumps(res))
elif obj["action"] == "getRecipeList":
offset = obj.get("offset", 0)
limit = obj.get("limit")
res = fm.get_recipe_list(offset, limit)
res["action"] = obj["action"]
wsock.send(json.dumps(res))
elif obj["action"] == "getModelList":
offset = obj.get("offset", 0)
limit = obj.get("limit")
res = fm.get_model_list()
res["action"] = obj["action"]
wsock.send(json.dumps(res))
elif obj["action"] == "startLearning":
recipe_id = obj["recipeId"]
data_id = obj["dataId"]
model_info = obj["info"]
config = obj["trainConfig"]
model = CNN(recipe_id)
res = model.train(config, data_id, wsock, model_info)
res["action"] = "finishLearning"
del model
wsock.send(json.dumps(res))
elif obj["action"] == "addRecipe":
recipe = obj["recipe"]
res = fm.save_recipe(recipe)
res["action"] = obj["action"]
wsock.send(json.dumps(res))
elif obj["action"] == "deleteModel":
model_id = obj["modelId"]
r = fm.delete_model(model_id)
log_debug(r)
res = {}
res["action"] = obj["action"]
res["modelId"] = model_id
wsock.send(json.dumps(res))
elif obj["action"] == "deleteRecipe":
recipe_id = obj["recipeId"]
r = fm.delete_recipe(recipe_id)
log_debug(r)
res = {}
res["action"] = obj["action"]
res["recipeId"] = recipe_id
wsock.send(json.dumps(res))
elif obj["action"] == "deleteData":
data_id = obj["dataId"]
r = fm.delete_data(data_id)
log_debug(r)
res = {}
res["action"] = obj["action"]
res["dataId"] = data_id
wsock.send(json.dumps(res))
elif obj["action"] == "updateData":
data = obj["dataInfo"]
file_id = obj["dataId"]
new_data = fm.put_data_info(data, file_id)
res = {
"data": new_data,
"action": obj["action"]
}
log_debug(res)
wsock.send(json.dumps(res))
elif obj["action"] == "updateModel":
model_id = obj["modelId"]
model = obj["model"]
put_res = fm.put_model_info(model, model_id)
res = {
"model": put_res["detail"],
"action": obj["action"]
}
log_debug(res)
wsock.send(json.dumps(res))
elif obj["action"] == "updateRecipe":
recipe_id = obj["recipeId"]
info = obj["info"]
res = fm.get_recipe(recipe_id)
if res and res.get("status") == "success":
body = res["detail"]["body"]
body["info"]["name"] = info["name"]
body["info"]["description"] = info["description"]
new_recipe = fm.update_recipe(recipe_id, body)
res = {
"recipe": new_recipe["detail"],
"action": obj["action"]
}
else:
res = {
"status": "error",
"action": obj["action"]
}
log_debug(res)
wsock.send(json.dumps(res))
except (UnicodeDecodeError, json.decoder.JSONDecodeError):
d["size"] += len(message)
d["uploading_file"] += message
response = {"status": "loading", "loadedSize": d["size"]}
print(response)
time.sleep(0.05) # for the progress bar.
wsock.send(json.dumps(response))
if d["size"] == int(d["file_size"]):
uploading_file = d["uploading_file"]
file_id = fm.generate_id()
result = fm.put_zip_file(uploading_file, file_id, is_expanding=True)
new_data = {
"name": d["name"],
"description": d["description"]
}
fm.put_data_info(new_data, file_id)
response = {"action": "uploaded", "fileId": file_id}
wsock.send(json.dumps(response))
def find_particles(image_scored,
image_thresholded,
min_dist,
n_particles_max,
peak_centering="center_of_mass"):
n_lit = image_thresholded.sum()
log_debug(logger, "%i pixels above threshold" % n_lit)
success = False
return_default = success, [], None, None, None, None, None, None, None, None
if n_lit == 0:
return return_default
else:
log_debug(logger, "Label image")
labels, n_labels = scipy.ndimage.measurements.label(image_thresholded)
i_labels = range(1, n_labels + 1)
if n_labels > n_particles_max:
log_info(
logger,
"%i labels - (frame overexposed? too many particles?), skipping analysis"
% n_labels)
return return_default
V = [image_scored[i_label == labels].max() for i_label in i_labels]
nx = image_thresholded.shape[1]
ny = image_thresholded.shape[0]
x, y = np.meshgrid(np.arange(nx), np.arange(ny))
x = x[image_thresholded]
y = y[image_thresholded]
l = labels[image_thresholded]
v = image_scored[image_thresholded]
if peak_centering == "center_of_mass":
log_debug(logger, "Determine centers of mass")
com = scipy.ndimage.measurements.center_of_mass(
image_thresholded, labels, i_labels)
X = [com_x for com_y, com_x in com]
Y = [com_y for com_y, com_x in com]
elif peak_centering == "center_to_max":
log_debug(logger, "Determine maximum positions")
X = []
Y = []
for i_label in i_labels:
i_max = (v * (l == i_label)).argmax()
X.append(x[i_max])
Y.append(y[i_max])
else:
log_and_raise_error(
logger, "%s is not a valid argument for peak_centering!" %
peak_centering)
dislocation = []
for i_label, xc, yc in zip(i_labels, X, Y):
i_max = (v * (l == i_label)).argmax()
dislocation.append(np.sqrt((x[i_max] - xc)**2 +
(y[i_max] - yc)**2))
merged = list(np.zeros(len(i_labels), dtype=np.bool))
# Merge too close peaks
log_debug(logger, "Merge too close points")
i_labels, labels, X, Y, V, merged, dists_closest_neighbor = merge_close_points(
i_labels, labels, X, Y, V, merged, min_dist)
log_debug(logger, "Clean up labels")
i_labels, labels = clean_up_labels(i_labels, labels)
n_labels = len(i_labels)
log_debug(logger, "Measure size of each peak")
areas = measure_areas(i_labels, labels)
success = True
areas = np.asarray(areas)
X = np.asarray(X)
Y = np.asarray(Y)
dislocation = np.asarray(dislocation)
V = np.asarray(V)
merged = np.asarray(merged)
dists_closest_neighbor = np.asarray(dists_closest_neighbor)
return success, i_labels, labels, areas, X, Y, V, merged, dists_closest_neighbor, dislocation
def train():
TIMESTAMP = "{0:%Y-%m-%d-%H-%M/}".format(datetime.now())
log.log_info('program start')
data, num_good, num_bad = util.load_train_data(num_data // 2)
log.log_debug('Data loading completed')
# resample
data, length = util.resample(data, 600)
data = util.reshape(data, length)
good_data_origin = data[:num_good, :]
bad_data_origin = data[num_good:, :]
# extract bad data for test and train
permutation = list(np.random.permutation(len(bad_data_origin)))
shuffled_bad_data = bad_data_origin[permutation, :]
test_bad_data = shuffled_bad_data[:int(num_bad * 0.3), :]
train_bad_data_origin = shuffled_bad_data[int(num_bad * 0.3):, :]
# extract corresponding good data for test and train
permutation = list(np.random.permutation(len(good_data_origin)))
shuffled_good_data = good_data_origin[permutation, :]
test_good_data = shuffled_good_data[:len(test_bad_data), :]
train_good_data = shuffled_good_data[len(test_bad_data):, :]
assert len(test_bad_data) == len(test_good_data)
# construct test data
test_y = np.array([1.] * len(test_good_data) + [0.] * len(test_bad_data), dtype=np.float).reshape(
(len(test_bad_data) + len(test_good_data), 1))
test_x = np.vstack((test_good_data, test_bad_data))
# expand the number of bad data for train
train_x = np.vstack((train_good_data, train_bad_data_origin))
train_y = np.array([1.] * len(train_good_data) + [0.] * len(train_bad_data_origin), dtype=np.float).reshape(
(len(train_bad_data_origin) + len(train_good_data), 1))
train_x, train_y, num_expand = util.expand(train_x, train_y)
# regularize
for i in range(len(train_x)):
train_x[i, :, 0] = util.regularize(train_x[i, :, 0])
train_x[i, :, 1] = util.regularize(train_x[i, :, 1])
train_x[i, :, 2] = util.regularize(train_x[i, :, 2])
for i in range(len(test_x)):
test_x[i, :, 0] = util.regularize(test_x[i, :, 0])
test_x[i, :, 1] = util.regularize(test_x[i, :, 1])
test_x[i, :, 2] = util.regularize(test_x[i, :, 2])
# random
train_x, train_y = util.shuffle_data(train_x, train_y)
log.log_debug('prepare completed')
log.log_info('convolution layers: ' + str(conv_layers))
log.log_info('filters: ' + str(filters))
log.log_info('full connected layers: ' + str(fc_layers))
log.log_info('learning rate: %f' % learning_rate)
log.log_info('keep prob: ' + str(keep_prob))
log.log_info('the number of expanding bad data: ' + str(num_expand))
log.log_info('mini batch size: ' + str(mini_batch_size))
if mini_batch_size != 0:
assert mini_batch_size <= len(train_x)
cnn = Cnn(conv_layers, fc_layers, filters, learning_rate)
(m, n_W0, n_C0) = train_x.shape
n_y = train_y.shape[1]
# construction calculation graph
cnn.initialize(n_W0, n_C0, n_y)
cost = cnn.cost()
optimizer = cnn.get_optimizer(cost)
predict, accuracy = cnn.predict()
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as sess:
# log for tensorboard
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter("resource/tsb/train/" + TIMESTAMP, sess.graph)
test_writer = tf.summary.FileWriter("resource/tsb/test/" + TIMESTAMP)
if enable_debug:
sess = tf_debug.LocalCLIDebugWrapperSession(sess)
sess.run(init)
for i in range(1, num_epochs + 1):
if mini_batch_size != 0:
num_mini_batches = int(m / mini_batch_size)
mini_batches = util.random_mini_batches(train_x, train_y, mini_batch_size)
cost_value = 0
for mini_batch in mini_batches:
(mini_batch_x, mini_batch_y) = mini_batch
_, temp_cost = sess.run([optimizer, cost], feed_dict={cnn.x: mini_batch_x, cnn.y: mini_batch_y,
cnn.keep_prob: keep_prob})
cost_value += temp_cost
cost_value /= num_mini_batches
else:
_, cost_value = sess.run([optimizer, cost],
feed_dict={cnn.x: train_x, cnn.y: train_y, cnn.keep_prob: keep_prob})
# disable dropout
summary_train, train_accuracy = sess.run([merged, accuracy],
feed_dict={cnn.x: train_x, cnn.y: train_y,
cnn.keep_prob: 1})
summary_test, test_accuracy = sess.run([merged, accuracy],
feed_dict={cnn.x: test_x, cnn.y: test_y, cnn.keep_prob: 1})
train_writer.add_summary(summary_train, i - 1)
test_writer.add_summary(summary_test, i - 1)
if print_detail and (i % 10 == 0 or i == 1):
info = '\nIteration %d\n' % i + \
'Cost: %f\n' % cost_value + \
'Train accuracy: %f\n' % train_accuracy + \
'Test accuracy: %f' % test_accuracy
log.log_info(info)
# stop when test>0.95 and train>0.99
if test_accuracy >= 0.95 and train_accuracy >= 0.99:
info = '\nIteration %d\n' % i + \
'Cost: %f\n' % cost_value + \
'Train accuracy: %f\n' % train_accuracy + \
'Test accuracy: %f' % test_accuracy
log.log_info(info)
saver.save(sess, "resource/model/" + TIMESTAMP)
break
saver.save(sess, "resource/model/" + TIMESTAMP)
train_writer.close()
test_writer.close()
log.log_info('program end')
def playing_idol_on_event_playing_actor_request_complete(
message_type, channel, channel_type, serialize):
# 获取请求代理
request_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.REQUEST_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorRequestComplete()
# 消息反序列化
TSerialization.deserialize(message, serialize)
# 获取副本对象
playing = idol_types.PlayingManager.get(message.playing_)
if playing == None:
log.log_error("获取 副本对象(%d) 失败" % message.playing_)
return None
# 获取玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
log.log_error("获取 玩家对象(%d) 失败" % message.actor_)
return None
# 玩家是否完成副本
if actor.get_finish() == 0:
log.log_error("玩家(%d) 未成完成idol副本" % message.actor_)
return None
# 获取副本配置
playing_config = idol_types.Config.get(message.template_)
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % message.template_)
return None
# 消耗玩家副本次数
request = ccrequest.playing.ttypes.RequestPlayingIncreaseComplete()
# request.actor_ = message.actor_
# request.playing_template_ = message.template_
request.playing_ = message.playing_
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INCREASE_COMPLETE, \
request_data, len(request_data))
# 请求完成消息
request = ccrequest.playing.ttypes.RequestPlayingComplete()
# request.actor_ = message.actor_
request.playing_ = message.playing_
# 抽奖
actor.draw_award_item(playing_config.get_draw_awards())
request.draw_award_ = actor.get_draw_award_item()
# 奖励
request.awards_ = playing_config.get_awards()
# 副本耗时
playing_result = ccentity.playing.ttypes.PlayingResultField()
playing_result.awarded_ = False
playing_result.award_count_ = 1
playing_result.paid_award_count_ = 0
playing_result.values_ = []
# result.value1: 花费时间
playing_result.values_.append(int(time.time() - actor.get_start_time()))
# 副本结果
request.result_ = playing_result
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_COMPLETE, \
request_data, len(request_data))
log.log_debug("玩家完成idol副本(%d)" % message.template_)
# 请求清除场景中的NPC
request_clear_npc = ccrequest.scene.ttypes.RequestSceneClearAllNpc()
request_clear_npc.scene_ = playing.get_scene()
request_clear_npc.delay_secs_ = 5
# 序列化
request_clear_npc_data = TSerialization.serialize(request_clear_npc)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_SCENE_CLEAR_ALL_NPC, \
request_clear_npc_data, len(request_clear_npc_data))
log.log_debug("请求清除 场景(%d) npc" % request_clear_npc.scene_)
def playing_plot_on_event_playing_actor_request_complete(
message_type, channel, channel_type, serialize):
# 获取请求代理
request_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.REQUEST_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorRequestComplete()
# 消息反序列化
TSerialization.deserialize(message, serialize)
# 获取副本对象
playing = plot_types.PlayingManager.get(message.playing_)
if playing == None:
log.log_error("获取 副本对象(%d) 失败" % message.playing_)
return None
# 获取玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
log.log_error("获取 玩家对象(%d) 失败" % message.actor_)
return None
# 玩家得分(星数) 应该为0
if actor.get_score() != 0:
log.log_error("玩家 得分(%d) 错误" % actor.get_score())
return None
# 获取副本配置
playing_config = plot_types.Config.get(message.template_)
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % message.template_)
return None
# 获取玩家通关需要杀死的NPC
pass_kill_npc = playing_config.get_pass_kill_npc()
if actor.get_kill_npc(pass_kill_npc) <= 0:
log.log_error("玩家 未能杀死NPC(%d) 不能通关" % pass_kill_npc)
return None
# 随机抽取一个道具
actor.draw_award_item(playing_config.get_draw_items())
# 统计副本花费时间
spend_time = time.time() - actor.get_start_time()
# 请求消息
request = ccrequest.playing.ttypes.RequestPlayingComplete()
# 玩家星数加1
actor.inc_score(1)
# 死亡次数低于配置次数星数加1
if actor.get_dead_count() <= playing_config.get_dead_count():
actor.inc_score(1)
# 花费时间低于配置时间星数加1
if spend_time <= playing_config.get_spend_time():
actor.inc_score(1)
# 杀死NPC个数大于配置个数星数加1
if actor.get_kill_npc_num() >= playing_config.get_npc_number():
actor.inc_score(1)
# 杀死隐藏NPC星数加1
if actor.get_kill_npc(playing_config.get_hide_npc()):
actor.inc_score(1)
# request.actor_ = message.actor_
request.playing_ = message.playing_
request.score_ = actor.get_score()
request.awards_ = []
award_field = ccentity.playing.ttypes.PlayingAwardField()
award_field.type_ = ccentity.resource.ttypes.ResourceType.RESOURCE
score = actor.get_score()
# 道具
for award in playing_config.get_awards():
if award.type_ == ccentity.resource.ttypes.ResourceType.RESOURCE:
award.number_ = award.number_ * score * 20 / 100
request.awards_.append(award)
# 抽奖奖励
request.draw_award_ = actor.get_draw_award_item()
# 副本耗时, 分数
playing_result = ccentity.playing.ttypes.PlayingResultField()
playing_result.awarded_ = False
playing_result.award_count_ = 1
playing_result.paid_award_count_ = 0
playing_result.values_ = []
# result.value1: 花费时间
playing_result.values_.append(int(spend_time))
# result.value2: 分数
playing_result.values_.append(score)
log.log_debug("[plot] spend_time=%d" % spend_time)
# 副本结果
request.result_ = playing_result
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_COMPLETE,\
request_data, len(request_data))
# 请求清除场景中的NPC
request_clear_npc = ccrequest.scene.ttypes.RequestSceneClearAllNpc()
request_clear_npc.scene_ = playing.get_scene()
request_clear_npc.delay_secs_ = 5
# 序列化
request_clear_npc_data = TSerialization.serialize(request_clear_npc)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_SCENE_CLEAR_ALL_NPC, \
request_clear_npc_data, len(request_clear_npc_data))
log.log_debug("请求清除 场景(%d) npc" % request_clear_npc.scene_)
@app.route('/images/<image_id>/probability', method="GET")
def get_probability(image_id):
res = prob.get_prob(image_id)
return put_response(res)
@app.route('/static/<file_type>/<file>')
def read_static(file_type, file):
if file_type == "js":
content_type = "text/javascript"
elif file_type == "css":
content_type = "text/css"
else:
content_type = "text/html"
with open('../static/'+file_type+'/'+file) as f:
data = f.read()
return put_response(data=data, content_type=content_type)
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument('--port', dest="port", type=int, default=8081)
parser.add_argument('--debug', dest="debug", action="store_true")
args = parser.parse_args()
port = args.port
if args.debug:
log_debug("debug mode.")
app.run(host="0.0.0.0", port=8081, debug=True, reloader=True)
else:
server = WSGIServer(("0.0.0.0", port), app, handler_class=WebSocketHandler)
log_debug("websocket server start. port:{}".format(port))
server.serve_forever()
def playing_plot_on_event_playing_actor_enter(message_type, channel,
channel_type, serialize):
# 获取事件交互代理
communicator_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.COMMUNICATOR_PROXY)
# 获取请求代理
request_proxy = variable_table.get_variable(
ccvariable.ttypes.Variable.REQUEST_PROXY)
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家杀死NPC事件、请求完成副本事件、角色被杀死事件
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_plot_on_event_actor_kill_npc")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_REQUEST_COMPLETE,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_plot_on_event_playing_actor_request_complete")
communicator_proxy.follow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_plot_on_event_actor_killed")
# 副本1需要关注玩家血量改变的事件
if message.template_ == 1:
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ROLE_CHANGE_HP, \
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR, \
"playing_plot_on_event_role_change_hp")
# 获取副本对象
playing = plot_types.PlayingManager.get(message.playing_)
if playing == None:
proxy.Logging.error("plot_types.PlayingManager.get(%d) failed." %
message.playing_)
return None
now = time.time()
# 获取玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
# 玩家不存在时，创建并加入副本中
actor = plot_types.Actor(message.actor_, now)
playing.add_actor(actor)
# 消耗玩家副本次数
request = ccrequest.playing.ttypes.RequestPlayingIncreaseComplete()
# request.actor_ = message.actor_
# request.playing_template_ = message.template_
request.playing_ = message.playing_
# 序列化
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INCREASE_COMPLETE, \
request_data, len(request_data))
# 副本管理器中加入一个玩家ID到副本ID的对应关系
plot_types.PlayingManager.add_actor(message.actor_, message.playing_)
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - actor.get_start_time()
request.scores_ = []
request.datas_ = []
# 循环获取玩家杀死的每个NPC
for (k, v) in actor.get_kill_npcs().items():
score_field = ccentity.playing.ttypes.PlayingScoreField()
score_field.type_ = ccentity.playing.ttypes.PlayingScoreType.KILL_NPC
score_field.key_ = k
score_field.value_ = v
request.scores_.append(score_field)
# 序列化消息
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR, \
request_data, len(request_data))
log.log_debug("玩家(%d)进入副本(id=%d,template=%d)" % \
(message.actor_, message.playing_, message.template_))
def close(self):
self._shrink_stacks()
log.log_debug(logger, "Closing file %s" % self._filename)
self._f.close()
