def playing_slime_on_timer_boss(id):
# 获取副本对象
playing = slime_types.PlayingManager.get(id)
if playing == None:
proxy.Logging.error("[slime] PlayingManager.get(%d) failed" % id)
return None
# 获取玩家对象
actor = proxy.EntityManager.get_actor(playing.get_actor())
if actor == None:
proxy.Logging.error("[slime] get actor(%d) failed" % playing.get_actor())
return None
status = actor.get_basic_status()
if status == ccentity.role.ttypes.RoleBasicStatus.STATUS_DIE:
# 先复活玩家
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_ = id
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_FAILURE, request)
proxy.Logging.debug("[slime] actor(%d) boss time expired." % playing.get_actor())
def playing_slime_on_timer_boss(id):
# 获取副本对象
playing = slime_types.PlayingManager.get(id)
if playing == None:
proxy.Logging.error("[slime] PlayingManager.get(%d) failed" % id)
return None
# 获取玩家对象
actor = proxy.EntityManager.get_actor(playing.get_actor())
if actor == None:
proxy.Logging.error("[slime] get actor(%d) failed" %
playing.get_actor())
return None
status = actor.get_basic_status()
if status == ccentity.role.ttypes.RoleBasicStatus.STATUS_DIE:
# 先复活玩家
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_ = id
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_FAILURE,
request)
proxy.Logging.debug("[slime] actor(%d) boss time expired." %
playing.get_actor())
def playing_team_on_event_playing_actor_leave(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorLeave()
TSerialization.deserialize(message, serialize)
# 取消关注玩家杀死NPC事件
proxy.Communicator.unfollow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_team_on_event_actor_kill_npc")
proxy.Communicator.unfollow(ccevent.ttypes.EventType.EVENT_SKILL_ATTACK_HIT,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_team_on_event_skill_attack_hit")
playing = team_types.PlayingManager.get(message.playing_)
if playing == None:
return None
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.debug("[team] playing.get_actor(%d) failed." % message.actor_)
return None
actor.set_leave(True)
# 副本管理器中删除玩家ID和副本ID的映射关系
team_types.PlayingManager.remove_actor(message.actor_)
proxy.Logging.debug("[team] actor(%d) leave from playing" % message.actor_)
def playing_slaughter_house_on_event_playing_actor_leave(
message_type, channel, channel_type, serialize):
message = ccevent.playing.ttypes.EventPlayingActorLeave()
TSerialization.deserialize(message, serialize)
proxy.Communicator.unfollow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slaughter_house_on_event_actor_killed")
proxy.Communicator.unfollow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slaughter_house_on_event_actor_kill_npc")
playing = slaughter_house_types.PlayingManager.get(message.playing_)
if playing == None:
return None
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("[slaughter_house] playing.get_actor(%d) failed." %
message.actor_)
return None
actor.leaving_ = True
slaughter_house_types.PlayingManager.remove_actor(message.actor_)
proxy.Logging.debug("[slaughter_house] actor(%d) leave from playing" %
message.actor_)
def playing_team_sync_ranking_actor(playing_id, actor_id):
# 获取副本对象
playing = team_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[team] PlayingManager.get(%d) failed." % playing_id)
return None
ranking = playing.get_ranking()
if ranking == None:
proxy.Logging.error("[team] playing.get_ranking() failed.")
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeRanking()
request.actors_ = []
request.ranking_ = []
request.actors_.append(actor_id)
for actor_rank in ranking.get_ranking():
actor = playing.get_actor(actor_rank.get_id())
if actor != None:
field = ccentity.playing.ttypes.PlayingRankingField()
field.name_ = actor.get_name()
field.value_ = actor_rank.get_damage()
request.ranking_.append(field)
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_RANKING, request)
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 playing_slaughter_house_on_event_playing_actor_leave(message_type, channel, channel_type, serialize):
message = ccevent.playing.ttypes.EventPlayingActorLeave()
TSerialization.deserialize(message, serialize)
proxy.Communicator.unfollow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slaughter_house_on_event_actor_killed")
proxy.Communicator.unfollow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slaughter_house_on_event_actor_kill_npc")
playing = slaughter_house_types.PlayingManager.get(message.playing_)
if playing == None:
return None
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("[slaughter_house] playing.get_actor(%d) failed." % message.actor_)
return None
actor.leaving_ = True;
slaughter_house_types.PlayingManager.remove_actor(message.actor_)
proxy.Logging.debug("[slaughter_house] actor(%d) leave from playing" % message.actor_)
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_slaughter_house_on_event_actor_killed(message_type, channel, channel_type, serialize):
message = ccevent.role.ttypes.EventRoleKilled()
TSerialization.deserialize(message, serialize)
if message.attacker_type_ != ccentity.entity.ttypes.EntityType.TYPE_ACTOR:
return None;
playing_id = slaughter_house_types.PlayingManager.get_actor_playing(message.id_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("[slaughter_house] PlayingManager.get_actor_playing(%d) failed."\
% message.id_)
return None
playing = slaughter_house_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[slaughter_house] PlayingManager.get(%d) failed." % playing_id)
return None
playing_config = slaughter_house_types.Config.get(playing.get_template())
if playing_config == None:
proxy.Logging.error("[slaughter_house] slaughter_house_types.Config.get(%d) failed."\
% playing.get_template())
return None
attacker_actor = playing.get_actor(message.attacker_id_)
if attacker_actor == None:
proxy.Logging.error("[slaughter_house] playing.get_actor(%d) failed."\
% message.attacker_id_)
return None
attacker_actor.score_ += playing_config.kill_actor_score_
playing.ranking_.add_score(message.attacker_id_, playing_config.kill_actor_score_)
proxy.Logging.debug("[slaughter_house] actor(%d) killed by actor(%d)"\
% (message.id_, message.attacker_id_))
def playing_soul_on_event_playing_actor_enter(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
TSerialization.deserialize(message, serialize)
# 关注玩家杀死NPC事件、请求完成副本事件
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_soul_on_event_actor_kill_npc")
playing = soul_types.PlayingManager.get(message.playing_)
if playing == None:
return None
actor = playing.get_actor(message.actor_)
if actor == None:
actor = soul_types.Actor(message.actor_)
playing.add_actor(actor)
# 副本管理器中建立一个玩家ID和副本ID的映射关系
soul_types.PlayingManager.add_actor(message.actor_, message.playing_)
now = time.time()
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - playing.get_start_time()
request.datas_ = []
request.scores_ = []
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR,\
request)
proxy.Logging.debug("[soul] actor(%d) enter into playing" % message.actor_)
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 playing_plot_on_event_role_change_hp(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.role.ttypes.EventRoleChangeHp()
# 消息反序列化
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
# 获取玩家对象
playing_actor = playing.get_actor(message.id_)
if playing_actor == None:
proxy.Logging.error("plot_types.PlayingManager.get_actor(%d) failed." % message.id_)
return None
# 隐藏NPC是否已召唤
if playing_actor.get_hide_npc() > 0:
return None
# 获得玩家交互对象
actor = proxy.EntityManager.get_actor(message.id_)
if actor == None:
proxy.Logging.error("proxy.EntityManager.get_actor(%d) failed." % message.id_)
return None
max_hp = actor.get_attr_role_aoi(ccentity.role.ttypes.RoleAoiFields.MAX_HP)
current_hp = actor.get_attr_role_aoi(ccentity.role.ttypes.RoleAoiFields.CURRENT_HP)
if current_hp > (max_hp * 20 / 100):
return None
playing_config = plot_types.Config.get(playing.get_template())
if playing_config == None:
proxy.Logging.error("获取 副本配置失败(%d)" % playing.get_template())
return None
playing_actor.inc_hide_npc(1)
facade_request.summon_npc(playing.get_scene(), playing_config.get_hide_npc(),\
actor.get_pos_x(), actor.get_pos_y(), 5, 5)
proxy.Logging.debug("玩家血量改变，触发隐藏BOSS");
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 playing_idol_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 = idol_types.PlayingManager.get_actor_playing(message.actor_)
if playing_id == None or playing_id == 0:
return None
# 获取副本对象
playing = idol_types.PlayingManager.get(playing_id)
if playing == None:
return None
# 获取副本配置
playing_config = idol_types.Config.get(playing.get_template_id())
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % playing.get_template_id())
return None
# 获取玩家通关需要杀死的NPC
pass_kill_npc = playing_config.get_pass_kill_npc()
if message.npc_template_ != pass_kill_npc:
log.log_error("玩家(%d) 杀死npc(%d) 不是通关npc(%d)" % \
(message.actor_, message.npc_template_, pass_kill_npc))
return None
# 获取副本玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
log.log_error("idol副本 获取actor(%d) 失败" % message.actor_)
return None
if actor.get_finish() == 0 and actor.get_dead_count() <= 0:
actor.set_finish()
# 请求同步玩家得分
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeScore()
request.actor_ = message.actor_
request.score_ = ccentity.playing.ttypes.PlayingScoreField(ccentity.playing.ttypes.PlayingScoreType.KILL_NPC, \
message.npc_template_, 1)
# 序列化消息
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_SCORE, \
request_data, len(request_data))
def playing_slaughter_house_on_event_actor_kill_npc(message_type, channel,
channel_type, serialize):
message = ccevent.actor.ttypes.EventActorKillNpc()
TSerialization.deserialize(message, serialize)
playing_id = slaughter_house_types.PlayingManager.get_actor_playing(
message.actor_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("[slaughter_house] PlayingManager.get_actor_playing(%d) failed."\
% (message.actor_))
return None
playing = slaughter_house_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[slaughter_house] PlayingManager.get(%d) failed."\
% (message.actor_))
return None
playing_config = slaughter_house_types.Config.get(playing.get_template())
if playing_config == None:
proxy.Logging.error("[slaughter_house] slaughter_house_types.Config.get(%d) failed."\
% (playing.get_template()))
return None
playing_cell = playing_types.Config.get(playing.get_template())
if playing_cell == None:
proxy.Logging.error("[slaughter_house] playing_types.Config.get(%d) failed."\
% (playing.get_template()))
return None
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("[slaughter_house] playing.get_actor(%d) failed."\
% (message.actor_))
return None
actor.score_ += playing_config.get_monster_score(message.npc_template_)
playing.ranking_.add_score(message.actor_,\
playing_config.get_monster_score(message.npc_template_))
if playing.group_ - 1 < len(playing_config.monster_groups_):
monster_group = playing_config.monster_groups_[playing.group_ - 1]
if monster_group == None:
proxy.Logging.error("[slaughter_house] playing_config.monster_groups_[%d] is none."\
% (playing.group_ - 1))
return None
if monster_group.boss_id_ == message.npc_template_:
summon_award_group(playing_id)
proxy.Logging.debug("[slaughter_house] actor(%d) kill npc(%d) score(%d)"\
% (message.actor_, message.npc_template_, playing_config.get_monster_score(message.npc_template_)))
def award_actor(actor_id, template, result):
proxy.Logging.debug("[soul] award_actor(%d,%d)" % (actor_id, template))
if result.awarded_ == True:
return None
# 得到奖励配置对象
award_config = soul_types.Config.get_awards()
if award_config == None:
proxy.Logging.error("[soul] Config.get_awards() failed.")
return None
draw_award_config = soul_types.Config.get_draw_awards()
if draw_award_config == None:
proxy.Logging.error("[soul] Config.get_draw_awards() failed.")
return None
# 请求增加副本奖励
request = ccrequest.playing.ttypes.RequestPlayingAwardActor()
request.actor_ = actor_id
request.playing_template_ = template
request.awards_ = []
# 固定奖励
for i in range(0, len(award_config) - 1):
request.awards_.append(award_config[i])
# 抽奖，如果在当前副本中，则使用已抽奖结果
draw_award = None
playing_id = soul_types.PlayingManager.get_actor_playing(actor_id)
if playing_id > 0:
draw_award = None
playing = soul_types.PlayingManager.get(playing_id)
if playing == None:
draw_award = None
else:
actor = playing.get_actor(actor_id)
if actor != None:
draw_award = actor.get_draw_award()
if draw_award != None:
request.awards_.append(draw_award)
else:
# 抽奖
draw_awards = soul_types.Config.get_draw_awards()
if draw_awards == None:
proxy.Logging.error("[soul] Config.get_draw_awards() failed.")
return None
draw_awards_size = len(draw_awards)
if draw_awards_size > 0:
request.awards_.append(draw_awards[random.randint(
0, draw_awards_size - 1)])
else:
request.awards_.append(ccentity.playing.ttypes.PlayingAwardField(\
ccentity.resource.ttypes.ResourceType.MIN, 0, 0))
# 发送请求
proxy.Request.request(
ccrequest.ttypes.RequestType.REQUEST_PLAYING_AWARD_ACTOR, request)
proxy.Logging.debug("[soul] request REQUEST_PLAYING_AWARD_ACTOR")
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 end_playing(playing_id):
playing = slaughter_house_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error(
"[slaughter_house] PlayingManager.get(%d) failed." % playing_id)
return None
facade_request.clear_scene_npcs(playing.get_scene(), 0, True)
proxy.Timer.remove(playing_id,
"playing_slaughter_house_on_timer_next_group")
ranking = 1
for actor_rank in playing.ranking_.get_ranking():
actor = playing.get_actor(actor_rank.id_)
if actor != None and actor.leaving_ == False:
request = ccrequest.playing.ttypes.RequestPlayingActorComplete()
request.playing_ = playing_id
request.draw_award_ = ccentity.playing.ttypes.PlayingAwardField(\
ccentity.resource.ttypes.ResourceType.MIN, 0, 0)
request.actor_ = actor_rank.id_
result = ccentity.playing.ttypes.PlayingResultField()
result.award_count_ = 1
result.paid_award_count_ = 0
result.awarded_ = False
# TODO: values_[0]中放入玩家名次
result.values_ = []
result.values_.append(ranking)
ranking += 1
request.awards_ = []
request.result_ = result
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_ACTOR_COMPLETE,\
request)
# 副本完成
request = ccrequest.playing.ttypes.RequestPlayingComplete()
request.playing_ = playing_id
result = ccentity.playing.ttypes.PlayingResultField()
result.values_ = []
result.award_count_ = 1
result.paid_award_count_ = 0
result.awarded_ = False
request.result_ = result
request.awards_ = []
request.draw_award_ = ccentity.playing.ttypes.PlayingAwardField(\
ccentity.resource.ttypes.ResourceType.MIN, 0, 0)
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_COMPLETE,\
request)
proxy.Logging.debug("[slaughter_house] end playing(%d)." % playing_id)
def end_playing(playing_id):
playing = slaughter_house_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[slaughter_house] PlayingManager.get(%d) failed." % playing_id)
return None
facade_request.clear_scene_npcs(playing.get_scene(), 0, True)
proxy.Timer.remove(playing_id, "playing_slaughter_house_on_timer_next_group")
ranking = 1
for actor_rank in playing.ranking_.get_ranking():
actor = playing.get_actor(actor_rank.id_)
if actor != None and actor.leaving_ == False:
request = ccrequest.playing.ttypes.RequestPlayingActorComplete()
request.playing_ = playing_id
request.draw_award_ = ccentity.playing.ttypes.PlayingAwardField(\
ccentity.resource.ttypes.ResourceType.MIN, 0, 0)
request.actor_ = actor_rank.id_
result = ccentity.playing.ttypes.PlayingResultField()
result.award_count_ = 1
result.paid_award_count_ = 0;
result.awarded_ = False
# TODO: values_[0]中放入玩家名次
result.values_ = []
result.values_.append(ranking);
ranking += 1
request.awards_ = []
request.result_ = result
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_ACTOR_COMPLETE,\
request)
# 副本完成
request = ccrequest.playing.ttypes.RequestPlayingComplete()
request.playing_ = playing_id
result = ccentity.playing.ttypes.PlayingResultField()
result.values_ = []
result.award_count_ = 1
result.paid_award_count_ = 0;
result.awarded_ = False
request.result_ = result
request.awards_ = []
request.draw_award_ = ccentity.playing.ttypes.PlayingAwardField(\
ccentity.resource.ttypes.ResourceType.MIN, 0, 0)
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_COMPLETE,\
request)
proxy.Logging.debug("[slaughter_house] end playing(%d)." % playing_id)
def playing_slaughter_house_on_event_actor_kill_npc(message_type, channel, channel_type, serialize):
message = ccevent.actor.ttypes.EventActorKillNpc()
TSerialization.deserialize(message, serialize)
playing_id = slaughter_house_types.PlayingManager.get_actor_playing(message.actor_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("[slaughter_house] PlayingManager.get_actor_playing(%d) failed."\
% (message.actor_))
return None
playing = slaughter_house_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[slaughter_house] PlayingManager.get(%d) failed."\
% (message.actor_))
return None
playing_config = slaughter_house_types.Config.get(playing.get_template())
if playing_config == None:
proxy.Logging.error("[slaughter_house] slaughter_house_types.Config.get(%d) failed."\
% (playing.get_template()))
return None
playing_cell = playing_types.Config.get(playing.get_template())
if playing_cell == None:
proxy.Logging.error("[slaughter_house] playing_types.Config.get(%d) failed."\
% (playing.get_template()))
return None
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("[slaughter_house] playing.get_actor(%d) failed."\
% (message.actor_))
return None
actor.score_ += playing_config.get_monster_score(message.npc_template_)
playing.ranking_.add_score(message.actor_,\
playing_config.get_monster_score(message.npc_template_))
if playing.group_ - 1 < len(playing_config.monster_groups_):
monster_group = playing_config.monster_groups_[playing.group_ - 1]
if monster_group == None:
proxy.Logging.error("[slaughter_house] playing_config.monster_groups_[%d] is none."\
% (playing.group_ - 1))
return None
if monster_group.boss_id_ == message.npc_template_:
summon_award_group(playing_id)
proxy.Logging.debug("[slaughter_house] actor(%d) kill npc(%d) score(%d)"\
% (message.actor_, message.npc_template_, playing_config.get_monster_score(message.npc_template_)))
def award_actor(actor_id, template, result):
proxy.Logging.debug("[soul] award_actor(%d,%d)" % (actor_id, template))
if result.awarded_ == True:
return None
# 得到奖励配置对象
award_config = soul_types.Config.get_awards()
if award_config == None:
proxy.Logging.error("[soul] Config.get_awards() failed.")
return None
draw_award_config = soul_types.Config.get_draw_awards()
if draw_award_config == None:
proxy.Logging.error("[soul] Config.get_draw_awards() failed.")
return None
# 请求增加副本奖励
request = ccrequest.playing.ttypes.RequestPlayingAwardActor()
request.actor_ = actor_id
request.playing_template_ = template
request.awards_ = []
# 固定奖励
for i in range(0, len(award_config) - 1):
request.awards_.append(award_config[i])
# 抽奖，如果在当前副本中，则使用已抽奖结果
draw_award = None
playing_id = soul_types.PlayingManager.get_actor_playing(actor_id)
if playing_id > 0:
draw_award = None
playing = soul_types.PlayingManager.get(playing_id)
if playing == None:
draw_award = None
else:
actor = playing.get_actor(actor_id)
if actor != None:
draw_award = actor.get_draw_award()
if draw_award != None:
request.awards_.append(draw_award)
else:
# 抽奖
draw_awards = soul_types.Config.get_draw_awards()
if draw_awards == None:
proxy.Logging.error("[soul] Config.get_draw_awards() failed.")
return None
draw_awards_size = len(draw_awards)
if draw_awards_size > 0:
request.awards_.append(draw_awards[random.randint(0, draw_awards_size - 1)])
else:
request.awards_.append(ccentity.playing.ttypes.PlayingAwardField(\
ccentity.resource.ttypes.ResourceType.MIN, 0, 0))
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_AWARD_ACTOR, request)
proxy.Logging.debug("[soul] request REQUEST_PLAYING_AWARD_ACTOR")
def playing_slaughter_house_on_event_playing_actor_enter(
message_type, channel, channel_type, serialize):
message = ccevent.playing.ttypes.EventPlayingActorEnter()
TSerialization.deserialize(message, serialize)
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slaughter_house_on_event_actor_killed")
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slaughter_house_on_event_actor_kill_npc")
ccactor = proxy.EntityManager.get_actor(message.actor_)
if ccactor == None:
return None
playing = slaughter_house_types.PlayingManager.get(message.playing_)
if playing == None:
proxy.Logging.error("[slaughter_house] slaughter_house_types.PlayingManager.get(%d) failed."\
% message.playing_)
return None
actor = playing.get_actor(message.actor_)
if actor == None:
actor = slaughter_house_types.Actor(message.actor_, ccactor.get_name())
playing.add_actor(actor)
playing.ranking_.add_score(message.actor_, 0)
sync_ranking_actor(message.playing_, message.actor_)
actor.leaving_ = False
slaughter_house_types.PlayingManager.add_actor(message.actor_,
message.playing_)
now = time.time()
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - playing.get_start_time()
request.datas_ = []
request.scores_ = []
request.scores_.append(
ccentity.playing.ttypes.PlayingScoreField(
ccentity.playing.ttypes.PlayingScoreType.STAGE, 0, playing.group_))
proxy.Request.request(
ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR, request)
proxy.Logging.debug("[slaughter_house] actor(%d) enter into playing" %
message.actor_)
def playing_idol_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 = idol_types.PlayingManager.get_actor_playing(message.actor_)
if playing_id == None or playing_id == 0:
return None
# 获取副本对象
playing = idol_types.PlayingManager.get(playing_id)
if playing == None:
return None
# 获取副本配置
playing_config = idol_types.Config.get(playing.get_template_id())
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % playing.get_template_id())
return None
# 获取玩家通关需要杀死的NPC
pass_kill_npc = playing_config.get_pass_kill_npc()
if message.npc_template_ != pass_kill_npc:
log.log_error("玩家(%d) 杀死npc(%d) 不是通关npc(%d)" % \
(message.actor_, message.npc_template_, pass_kill_npc))
return None
# 获取副本玩家对象
actor = playing.get_actor(message.actor_)
if actor == None:
log.log_error("idol副本 获取actor(%d) 失败" % message.actor_)
return None
if actor.get_finish() == 0 and actor.get_dead_count() <= 0:
actor.set_finish()
# 请求同步玩家得分
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeScore()
request.actor_ = message.actor_
request.score_ = ccentity.playing.ttypes.PlayingScoreField(ccentity.playing.ttypes.PlayingScoreType.KILL_NPC, \
message.npc_template_, 1)
# 序列化消息
request_data = TSerialization.serialize(request)
# 发送请求
request_proxy.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_SCORE, \
request_data, len(request_data))
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 playing_slaughter_house_on_event_playing_actor_enter(message_type, channel, channel_type, serialize):
message = ccevent.playing.ttypes.EventPlayingActorEnter()
TSerialization.deserialize(message, serialize)
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ROLE_KILLED,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slaughter_house_on_event_actor_killed")
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slaughter_house_on_event_actor_kill_npc")
ccactor = proxy.EntityManager.get_actor(message.actor_)
if ccactor == None:
return None
playing = slaughter_house_types.PlayingManager.get(message.playing_)
if playing == None:
proxy.Logging.error("[slaughter_house] slaughter_house_types.PlayingManager.get(%d) failed."\
% message.playing_)
return None
actor = playing.get_actor(message.actor_)
if actor == None:
actor = slaughter_house_types.Actor(message.actor_, ccactor.get_name())
playing.add_actor(actor)
playing.ranking_.add_score(message.actor_, 0)
sync_ranking_actor(message.playing_, message.actor_)
actor.leaving_ = False;
slaughter_house_types.PlayingManager.add_actor(message.actor_, message.playing_)
now = time.time()
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - playing.get_start_time()
request.datas_ = []
request.scores_ = []
request.scores_.append(ccentity.playing.ttypes.PlayingScoreField(
ccentity.playing.ttypes.PlayingScoreType.STAGE, 0, playing.group_))
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR,
request)
proxy.Logging.debug("[slaughter_house] actor(%d) enter into playing" % message.actor_)
def award_actor(actor, template, result):
proxy.Logging.debug("[plot] award_actor(%d,%d)" % (actor, template))
if result.awarded_ == True:
return None
# 配置
playing_config = plot_types.Config.get(template)
if playing_config == None:
log.log_error("找不到日常副本配置(%d)" % template)
return None
# 抽奖
draw_items = playing_config.get_draw_items()
if draw_items == None:
proxy.Logging.error("[plot] playing_config.get_draw_items() failed.")
return None
score = result.values_[1]
# 请求增加副本奖励
request = ccrequest.playing.ttypes.RequestPlayingAwardActor()
request.actor_ = actor
request.playing_template_ = template
request.awards_ = []
# 固定奖励
award_field = ccentity.playing.ttypes.PlayingAwardField()
award_field.type_ = ccentity.resource.ttypes.ResourceType.ITEM
for award in playing_config.get_awards():
request.awards_.append(award)
# 抽奖
draw_award = None
playing_id = plot_types.PlayingManager.get_actor_playing(actor)
if playing_id != 0:
playing = plot_types.PlayingManager.get(playing_id)
if playing != None:
playing_actor = playing.get_actor(actor)
if playing_actor != None:
draw_award = playing_actor.get_draw_award_item()
if draw_award == None:
draw_items_size = len(draw_items)
if draw_items_size > 0:
request.awards_.append(draw_items[random.randint(
0, draw_items_size - 1)])
else:
request.awards_.append(draw_award)
# 发送请求
proxy.Request.request(
ccrequest.ttypes.RequestType.REQUEST_PLAYING_AWARD_ACTOR, request)
proxy.Logging.debug("[plot] request REQUEST_PLAYING_AWARD_ACTOR")
def playing_slime_on_timer_slime(id):
# 获取副本对象
playing = slime_types.PlayingManager.get(id)
if playing == None:
proxy.Logging.error("[slime] PlayingManager.get(%d) failed" % id)
return None
chessboard = playing.get_chessboard()
if chessboard == None:
proxy.Logging.error("[slime] playing.get_chessboard() failed")
return None
chessboard.erase_all()
x, y = slime_types.Config.get_boss_position()
facade_request.summon_npc(playing.get_scene(), slime_types.Config.get_boss(), x, y)
proxy.Timer.add(id, slime_types.Config.get_boss_time() * 1000, 1, "playing_slime_on_timer_boss")
# 设置为Boss阶段
playing.set_section_boss()
playing.set_boss_summon_time(time.time())
proxy.Logging.debug("[slime] actor(%d) slime time expired." % playing.get_actor())
def award_actor(actor, template, result):
proxy.Logging.debug("[plot] award_actor(%d,%d)" % (actor, template))
if result.awarded_ == True:
return None
# 配置
playing_config = plot_types.Config.get(template)
if playing_config == None:
log.log_error("找不到日常副本配置(%d)" % template)
return None
# 抽奖
draw_items = playing_config.get_draw_items()
if draw_items == None:
proxy.Logging.error("[plot] playing_config.get_draw_items() failed.")
return None
score = result.values_[1]
# 请求增加副本奖励
request = ccrequest.playing.ttypes.RequestPlayingAwardActor()
request.actor_ = actor
request.playing_template_ = template
request.awards_ = []
# 固定奖励
award_field = ccentity.playing.ttypes.PlayingAwardField()
award_field.type_ = ccentity.resource.ttypes.ResourceType.ITEM
for award in playing_config.get_awards():
request.awards_.append(award)
# 抽奖
draw_award = None
playing_id = plot_types.PlayingManager.get_actor_playing(actor)
if playing_id != 0:
playing = plot_types.PlayingManager.get(playing_id)
if playing != None:
playing_actor = playing.get_actor(actor)
if playing_actor != None:
draw_award = playing_actor.get_draw_award_item()
if draw_award == None:
draw_items_size = len(draw_items)
if draw_items_size > 0:
request.awards_.append(draw_items[random.randint(0, draw_items_size - 1)])
else:
request.awards_.append(draw_award)
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_AWARD_ACTOR, request)
proxy.Logging.debug("[plot] request REQUEST_PLAYING_AWARD_ACTOR")
def sync_ranking_actor(playing_id, actor_id):
playing = slaughter_house_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[slaughter_house] PlayingManager.get(%d) failed." % playing_id)
return None
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeRanking()
request.actors_ = []
request.ranking_ = []
request.actors_.append(actor_id)
for actor_rank in playing.ranking_.get_ranking():
actor = playing.get_actor(actor_rank.id_)
if actor != None:
field = ccentity.playing.ttypes.PlayingRankingField()
field.name_ = actor.get_name()
field.value_ = actor_rank.score_
request.ranking_.append(field)
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_RANKING, request)
def playing_slime_on_timer_slime(id):
# 获取副本对象
playing = slime_types.PlayingManager.get(id)
if playing == None:
proxy.Logging.error("[slime] PlayingManager.get(%d) failed" % id)
return None
chessboard = playing.get_chessboard()
if chessboard == None:
proxy.Logging.error("[slime] playing.get_chessboard() failed")
return None
chessboard.erase_all()
x, y = slime_types.Config.get_boss_position()
facade_request.summon_npc(playing.get_scene(),
slime_types.Config.get_boss(), x, y)
proxy.Timer.add(id,
slime_types.Config.get_boss_time() * 1000, 1,
"playing_slime_on_timer_boss")
# 设置为Boss阶段
playing.set_section_boss()
playing.set_boss_summon_time(time.time())
proxy.Logging.debug("[slime] actor(%d) slime time expired." %
playing.get_actor())
def playing_slaughter_house_on_event_actor_killed(message_type, channel,
channel_type, serialize):
message = ccevent.role.ttypes.EventRoleKilled()
TSerialization.deserialize(message, serialize)
if message.attacker_type_ != ccentity.entity.ttypes.EntityType.TYPE_ACTOR:
return None
playing_id = slaughter_house_types.PlayingManager.get_actor_playing(
message.id_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("[slaughter_house] PlayingManager.get_actor_playing(%d) failed."\
% message.id_)
return None
playing = slaughter_house_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error(
"[slaughter_house] PlayingManager.get(%d) failed." % playing_id)
return None
playing_config = slaughter_house_types.Config.get(playing.get_template())
if playing_config == None:
proxy.Logging.error("[slaughter_house] slaughter_house_types.Config.get(%d) failed."\
% playing.get_template())
return None
attacker_actor = playing.get_actor(message.attacker_id_)
if attacker_actor == None:
proxy.Logging.error("[slaughter_house] playing.get_actor(%d) failed."\
% message.attacker_id_)
return None
attacker_actor.score_ += playing_config.kill_actor_score_
playing.ranking_.add_score(message.attacker_id_,
playing_config.kill_actor_score_)
proxy.Logging.debug("[slaughter_house] actor(%d) killed by actor(%d)"\
% (message.id_, message.attacker_id_))
def playing_team_on_event_skill_attack_hit(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.skill.ttypes.EventSkillAttackHit()
TSerialization.deserialize(message, serialize)
if message.dest_type_ != ccentity.entity.ttypes.EntityType.TYPE_NPC or\
message.type_ != ccentity.entity.ttypes.EntityType.TYPE_ACTOR:
return None;
if message.hurt_type_ != ccentity.skill.ttypes.SkillHurtType.PHYSICS_ATTACK and\
message.hurt_type_ != ccentity.skill.ttypes.SkillHurtType.MAGIC_ATTACK and\
message.hurt_type_ != ccentity.skill.ttypes.SkillHurtType.REDUCE_HP:
return None
# 获取玩家所在副本ID
playing_id = team_types.PlayingManager.get_actor_playing(message.id_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("[team] PlayingManager.get_actor_playing(%d) failed" % message.id_)
return None
playing = team_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[team] PlayingManager.get(%d) failed" % playing_id)
return None
actor = playing.get_actor(message.id_)
if actor == None:
proxy.Logging.error("[team] playing.get_actor(%d) failed" % message.id_)
return None
ranking = playing.get_ranking()
if ranking == None:
proxy.Logging.error("[team] playing.get_ranking() failed.")
return None;
ranking.add_damage(message.id_, message.value_)
actor.add_damage(message.value_)
proxy.Logging.debug("[team] actor(%d) hit npc(%d)" % (message.id_, message.dest_id_))
def award_actor(actor, template, result):
proxy.Logging.debug("[idol] award_actor(%d,%d)" % (actor, template))
if result.awarded_ == True:
return None
# 获取副本配置
playing_config = idol_types.Config.get(template)
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % template)
return None
# 抽奖
draw_awards = playing_config.get_draw_awards()
if draw_awards == None:
proxy.Logging.error("[idol] playing_config.get_draw_awards() failed.")
return None
# 请求增加副本奖励
request = ccrequest.playing.ttypes.RequestPlayingAwardActor()
request.actor_ = actor
request.playing_template_ = template
# 固定奖励
request.awards_ = playing_config.get_awards()
# 抽奖
draw_award = None
playing_id = idol_types.PlayingManager.get_actor_playing(actor)
if playing_id != 0:
playing = idol_types.PlayingManager.get(playing_id)
if playing != None:
playing_actor = playing.get_actor(actor)
if playing_actor != None:
draw_award = playing_actor.get_draw_award_item()
if draw_award == None:
draw_items_size = len(draw_awards)
if draw_items_size > 0:
request.awards_.append(draw_awards[random.randint(0, draw_items_size - 1)])
else:
request.awards_.append(draw_award)
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_AWARD_ACTOR, request)
proxy.Logging.debug("[idol] request REQUEST_PLAYING_AWARD_ACTOR")
def award_actor(actor, template, result):
proxy.Logging.debug("[idol] award_actor(%d,%d)" % (actor, template))
if result.awarded_ == True:
return None
# 获取副本配置
playing_config = idol_types.Config.get(template)
if playing_config == None:
log.log_error("获取 副本配置失败(%d)" % template)
return None
# 抽奖
draw_awards = playing_config.get_draw_awards()
if draw_awards == None:
proxy.Logging.error("[idol] playing_config.get_draw_awards() failed.")
return None
# 请求增加副本奖励
request = ccrequest.playing.ttypes.RequestPlayingAwardActor()
request.actor_ = actor
request.playing_template_ = template
# 固定奖励
request.awards_ = playing_config.get_awards()
# 抽奖
draw_award = None
playing_id = idol_types.PlayingManager.get_actor_playing(actor)
if playing_id != 0:
playing = idol_types.PlayingManager.get(playing_id)
if playing != None:
playing_actor = playing.get_actor(actor)
if playing_actor != None:
draw_award = playing_actor.get_draw_award_item()
if draw_award == None:
draw_items_size = len(draw_awards)
if draw_items_size > 0:
request.awards_.append(draw_awards[random.randint(0, draw_items_size - 1)])
else:
request.awards_.append(draw_award)
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_AWARD_ACTOR, request)
proxy.Logging.debug("[idol] request REQUEST_PLAYING_AWARD_ACTOR")
def playing_team_sync_ranking(id):
# 获取副本对象
playing = team_types.PlayingManager.get(id)
if playing == None:
proxy.Logging.error("[team] PlayingManager.get(%d) failed." % id)
return None
actors = playing.get_actors()
if actors == None:
proxy.Logging.error("[team] playing.get_actors() failed.")
return None
ranking = playing.get_ranking()
if ranking == None:
proxy.Logging.error("[team] playing.get_ranking() failed.")
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeRanking()
request.actors_ = []
request.ranking_ = []
"""
for (k,v) in actors.items():
request.actors_.append(k)
"""
for actor_rank in ranking.get_ranking():
actor = playing.get_actor(actor_rank.get_id())
if actor != None:
field = ccentity.playing.ttypes.PlayingRankingField()
field.name_ = actor.get_name()
field.value_ = actor_rank.get_damage()
request.ranking_.append(field)
if actor.get_leave() == False:
request.actors_.append(actor_rank.get_id())
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_RANKING, request)
proxy.Logging.debug("[team] playing_team_on_timer_sync_ranking expired.")
def sync_ranking_actor(playing_id, actor_id):
playing = slaughter_house_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error(
"[slaughter_house] PlayingManager.get(%d) failed." % playing_id)
return None
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeRanking()
request.actors_ = []
request.ranking_ = []
request.actors_.append(actor_id)
for actor_rank in playing.ranking_.get_ranking():
actor = playing.get_actor(actor_rank.id_)
if actor != None:
field = ccentity.playing.ttypes.PlayingRankingField()
field.name_ = actor.get_name()
field.value_ = actor_rank.score_
request.ranking_.append(field)
proxy.Request.request(
ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_RANKING,
request)
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 playing_soul_on_event_playing_actor_enter(message_type, channel,
channel_type, serialize):
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
TSerialization.deserialize(message, serialize)
# 关注玩家杀死NPC事件、请求完成副本事件
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_soul_on_event_actor_kill_npc")
playing = soul_types.PlayingManager.get(message.playing_)
if playing == None:
return None
actor = playing.get_actor(message.actor_)
if actor == None:
actor = soul_types.Actor(message.actor_)
playing.add_actor(actor)
# 副本管理器中建立一个玩家ID和副本ID的映射关系
soul_types.PlayingManager.add_actor(message.actor_, message.playing_)
now = time.time()
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - playing.get_start_time()
request.datas_ = []
request.scores_ = []
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR,\
request)
proxy.Logging.debug("[soul] actor(%d) enter into playing" % message.actor_)
def playing_team_on_event_actor_kill_npc(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.actor.ttypes.EventActorKillNpc()
TSerialization.deserialize(message, serialize)
# 获取玩家所在副本ID
playing_id = team_types.PlayingManager.get_actor_playing(message.actor_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("[team] PlayingManager.get_actor_playing(%d) failed" % message.actor_)
return None
playing = team_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[team] PlayingManager.get(%d) failed" % playing_id)
return None
playing_config = team_types.Config.get(playing.get_template())
if playing_config == None:
proxy.Logging.error("[team] team_types.Config.get(%d) failed." % playing.get_template())
return None
playing_cell = playing_types.Config.get(playing.get_template())
if playing_cell == None:
proxy.Logging.debug("[team] playing_types.Config.get(%d) failed." % playing.get_template())
return None
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("[team] playing.get_actor(%d) failed" % message.actor_)
return None
playing.inc_kill_npc(message.npc_template_)
actors = playing.get_actors()
if actors == None:
proxy.Logging.error("[team] playing.get_actors() failed")
return None
if playing_config.summon_next_npc(playing.get_scene(), playing.get_next_pos()) == False:
playing_team_sync_ranking(playing_id)
request = ccrequest.playing.ttypes.RequestPlayingComplete()
request.playing_ = playing_id
result = ccentity.playing.ttypes.PlayingResultField()
result.values_ = []
result.award_count_ = 1
result.paid_award_count_ = 0;
result.awarded_ = False
# result.value1: 花费时间
request.result_ = result
request.awards_ = []
for award in playing_cell.awards_:
request.awards_.append(award)
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_COMPLETE,\
request)
# 设置副本已完成
playing.set_complete()
# 取消定时器
proxy.Timer.remove(playing_id, "playing_team_on_timer_playing")
proxy.Timer.remove(playing_id, "playing_team_on_timer_sync_ranking")
# 同步一次排行
proxy.Logging.debug("[team] complete playing")
# 同步得分
for (k,v) in actors.items():
request = ccrequest.playing.ttypes.RequestPlayingSynchronizeScore()
request.actor_ = k
# 分数对象(得分类型=杀死NPC, key=NPC模板ID, value=当前杀死的个数)
score_field = ccentity.playing.ttypes.PlayingScoreField(ccentity.playing.ttypes.PlayingScoreType.KILL_NPC,\
message.npc_template_, playing.get_kill_npc(message.npc_template_))
request.score_ = score_field
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_SYNCHRONIZE_SCORE,\
request)
if playing.get_complete() == True:
award_actor = playing.get_actor(k)
if award_actor == None:
proxy.Logging.debug("[team] playing.get_actor(%d) failed." % k)
return None
# 不在副本内不给奖励
if award_actor.get_leave() == False:
# 直接给奖励
request_award = ccrequest.playing.ttypes.RequestPlayingAwardActor()
request_award.actor_ = k
request_award.playing_template_ = playing.get_template()
request_award.awards_ = []
for award in playing_cell.awards_:
request_award.awards_.append(award)
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_AWARD_ACTOR, request_award)
proxy.Logging.debug("[team] add_award award")
playing.next_pos()
proxy.Logging.debug("[team] actor(%d) kill npc(%d)" % (message.actor_, message.npc_template_))
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_)
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_team_on_event_playing_actor_enter(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
TSerialization.deserialize(message, serialize)
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_team_on_event_actor_kill_npc")
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_SKILL_ATTACK_HIT,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_team_on_event_skill_attack_hit")
ccactor = proxy.EntityManager.get_actor(message.actor_)
if ccactor == None:
return None
playing = team_types.PlayingManager.get(message.playing_)
if playing == None:
return None
ranking = playing.get_ranking()
if ranking == None:
proxy.Logging.error("[team] playing.get_ranking() failed.")
return None;
actor = playing.get_actor(message.actor_)
if actor == None:
actor = team_types.Actor(message.actor_, ccactor.get_name())
playing.add_actor(actor)
ranking.add_damage(message.actor_, 0)
playing_team_sync_ranking_actor(message.playing_, message.actor_)
# 消耗玩家副本次数
request = ccrequest.playing.ttypes.RequestPlayingActorIncreaseComplete()
request.playing_template_ = playing.get_template()
request.actor_ = message.actor_
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_ACTOR_INCREASE_COMPLETE,\
request)
actor.set_leave(False)
# 副本管理器中建立一个玩家ID和副本ID的映射关系
team_types.PlayingManager.add_actor(message.actor_, message.playing_)
now = time.time()
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - playing.get_start_time()
request.datas_ = []
request.scores_ = []
# 循环获取玩家杀死的每个NPC
for (k,v) in playing.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);
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR,\
request)
proxy.Logging.debug("[team] actor(%d) enter into playing" % message.actor_)
def playing_slime_on_event_playing_actor_enter(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家杀死NPC事件、请求完成副本事件
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slime_on_event_actor_kill_npc")
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_REQUEST_COMPLETE,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slime_on_event_playing_actor_request_complete")
playing = slime_types.PlayingManager.get(message.playing_)
if playing == None:
return None
now = time.time()
actor = playing.get_actor()
if actor == 0:
playing.set_start_time(now)
playing.set_actor(message.actor_)
# 消耗玩家副本次数
request = ccrequest.playing.ttypes.RequestPlayingIncreaseComplete()
# request.actor_ = message.actor_
# request.playing_template_ = message.template_
request.playing_ = message.playing_
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INCREASE_COMPLETE,\
request)
proxy.Timer.add(message.playing_, slime_types.Config.get_slime_time() * 1000, 1, "playing_slime_on_timer_slime")
# 副本管理器中建立一个玩家ID和副本ID的映射关系
slime_types.PlayingManager.add_actor(message.actor_, message.playing_)
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - playing.get_start_time()
# datas = [剩余体力, 阶段, 当前阶段剩余时间]
request.datas_ = []
request.datas_.append(slime_types.Config.get_max_power() - playing.get_spend_power())
if playing.get_section_boss() == True:
request.datas_.append(2)
request.datas_.append(now - playing.get_boss_summon_time())
else:
request.datas_.append(1)
# 第一阶段剩下的时间
elapse_time = now - playing.get_start_time()
if elapse_time <= slime_types.Config.get_slime_time():
request.datas_.append(slime_types.Config.get_slime_time() - elapse_time)
else:
request.datas_.append(0)
request.scores_ = []
request.scores_.append(ccentity.playing.ttypes.PlayingScoreField(\
ccentity.playing.ttypes.PlayingScoreType.KILL_NPC, 0, playing.get_score()))
request.scores_.append(ccentity.playing.ttypes.PlayingScoreField(\
ccentity.playing.ttypes.PlayingScoreType.POWER, 0,\
slime_types.Config.get_max_power() - playing.get_spend_power()))
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR,\
request)
# 转为临时技能形态
facade_request.change_skill_form(ccentity.entity.ttypes.EntityType.TYPE_ACTOR,\
message.actor_, ccentity.skill.ttypes.SkillFormType.TEMP)
# 增加临时技能
facade_request.add_temp_skill(ccentity.entity.ttypes.EntityType.TYPE_ACTOR,\
message.actor_, 100, 1)
facade_request.add_temp_skill(ccentity.entity.ttypes.EntityType.TYPE_ACTOR,\
message.actor_, 200, 1)
facade_request.add_temp_skill(ccentity.entity.ttypes.EntityType.TYPE_ACTOR,\
message.actor_, 300, 1)
proxy.Logging.debug("[slime] actor(%d) enter into playing" % message.actor_)
def playing_soul_on_event_actor_kill_npc(message_type, channel, channel_type,
serialize):
# 事件消息
message = ccevent.actor.ttypes.EventActorKillNpc()
TSerialization.deserialize(message, serialize)
# 获取玩家所在副本ID
playing_id = soul_types.PlayingManager.get_actor_playing(message.actor_)
if playing_id == None or playing_id == 0:
proxy.Logging.error(
"[soul] PlayingManager.get_actor_playing(%d) failed" %
message.actor_)
return None
playing = soul_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[soul] PlayingManager.get(%d) failed" %
playing_id)
return None
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("[soul] playing.get_actor(%d) failed" %
message.actor_)
return None
if message.npc_template_ == soul_types.Config.get_boss():
request = ccrequest.playing.ttypes.RequestPlayingComplete()
request.playing_ = playing_id
result = ccentity.playing.ttypes.PlayingResultField()
result.values_ = []
result.award_count_ = 1
result.paid_award_count_ = 0
result.awarded_ = False
request.result_ = result
request.awards_ = []
# 得到奖励
awards = soul_types.Config.get_awards()
if awards == None:
proxy.Logging.error("[soul] Config.get_awards() failed")
return None
for i in range(0, len(awards) - 1):
request.awards_.append(awards[i])
request.draw_awards_ = []
# 得到抽奖奖励
draw_awards = soul_types.Config.get_draw_awards()
if draw_awards == None:
proxy.Logging.error("[soul] Config.get_draw_awards() failed")
return None
draw_awards_size = len(draw_awards)
if draw_awards_size > 0:
request.draw_award_ = draw_awards[random.randint(
0, draw_awards_size - 1)]
actor.set_draw_award(request.draw_award_)
else:
return None
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_COMPLETE,\
request)
# 消耗玩家副本次数
request = ccrequest.playing.ttypes.RequestPlayingIncreaseComplete()
request.playing_ = playing_id
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INCREASE_COMPLETE,\
request)
playing.set_complete()
# 取消定时器
proxy.Timer.remove(playing_id, "playing_soul_on_timer_playing")
proxy.Logging.debug("[soul] complete playing")
proxy.Logging.debug("[soul] actor(%d) kill npc(%d)" %
(message.actor_, message.npc_template_))
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_soul_on_event_actor_kill_npc(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.actor.ttypes.EventActorKillNpc()
TSerialization.deserialize(message, serialize)
# 获取玩家所在副本ID
playing_id = soul_types.PlayingManager.get_actor_playing(message.actor_)
if playing_id == None or playing_id == 0:
proxy.Logging.error("[soul] PlayingManager.get_actor_playing(%d) failed" % message.actor_)
return None
playing = soul_types.PlayingManager.get(playing_id)
if playing == None:
proxy.Logging.error("[soul] PlayingManager.get(%d) failed" % playing_id)
return None
actor = playing.get_actor(message.actor_)
if actor == None:
proxy.Logging.error("[soul] playing.get_actor(%d) failed" % message.actor_)
return None
if message.npc_template_ == soul_types.Config.get_boss():
request = ccrequest.playing.ttypes.RequestPlayingComplete()
request.playing_ = playing_id
result = ccentity.playing.ttypes.PlayingResultField()
result.values_ = []
result.award_count_ = 1
result.paid_award_count_ = 0;
result.awarded_ = False
request.result_ = result
request.awards_ = []
# 得到奖励
awards = soul_types.Config.get_awards()
if awards == None:
proxy.Logging.error("[soul] Config.get_awards() failed")
return None
for i in range(0, len(awards) - 1):
request.awards_.append(awards[i])
request.draw_awards_ = []
# 得到抽奖奖励
draw_awards = soul_types.Config.get_draw_awards()
if draw_awards == None:
proxy.Logging.error("[soul] Config.get_draw_awards() failed")
return None
draw_awards_size = len(draw_awards)
if draw_awards_size > 0:
request.draw_award_ = draw_awards[random.randint(0, draw_awards_size - 1)]
actor.set_draw_award(request.draw_award_)
else:
return None
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_COMPLETE,\
request)
# 消耗玩家副本次数
request = ccrequest.playing.ttypes.RequestPlayingIncreaseComplete()
request.playing_ = playing_id
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INCREASE_COMPLETE,\
request)
playing.set_complete()
# 取消定时器
proxy.Timer.remove(playing_id, "playing_soul_on_timer_playing")
proxy.Logging.debug("[soul] complete playing")
proxy.Logging.debug("[soul] actor(%d) kill npc(%d)" % (message.actor_, message.npc_template_))
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_)
def playing_plot_on_event_role_change_hp(message_type, channel, channel_type,
serialize):
# 事件消息
message = ccevent.role.ttypes.EventRoleChangeHp()
# 消息反序列化
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
# 获取玩家对象
playing_actor = playing.get_actor(message.id_)
if playing_actor == None:
proxy.Logging.error("plot_types.PlayingManager.get_actor(%d) failed." %
message.id_)
return None
# 隐藏NPC是否已召唤
if playing_actor.get_hide_npc() > 0:
return None
# 获得玩家交互对象
actor = proxy.EntityManager.get_actor(message.id_)
if actor == None:
proxy.Logging.error("proxy.EntityManager.get_actor(%d) failed." %
message.id_)
return None
max_hp = actor.get_attr_role_aoi(ccentity.role.ttypes.RoleAoiFields.MAX_HP)
current_hp = actor.get_attr_role_aoi(
ccentity.role.ttypes.RoleAoiFields.CURRENT_HP)
if current_hp > (max_hp * 20 / 100):
return None
playing_config = plot_types.Config.get(playing.get_template())
if playing_config == None:
proxy.Logging.error("获取 副本配置失败(%d)" % playing.get_template())
return None
playing_actor.inc_hide_npc(1)
facade_request.summon_npc(playing.get_scene(), playing_config.get_hide_npc(),\
actor.get_pos_x(), actor.get_pos_y(), 5, 5)
proxy.Logging.debug("玩家血量改变，触发隐藏BOSS")
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 playing_slime_on_event_playing_actor_enter(message_type, channel,
channel_type, serialize):
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家杀死NPC事件、请求完成副本事件
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slime_on_event_actor_kill_npc")
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_REQUEST_COMPLETE,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_slime_on_event_playing_actor_request_complete")
playing = slime_types.PlayingManager.get(message.playing_)
if playing == None:
return None
now = time.time()
actor = playing.get_actor()
if actor == 0:
playing.set_start_time(now)
playing.set_actor(message.actor_)
# 消耗玩家副本次数
request = ccrequest.playing.ttypes.RequestPlayingIncreaseComplete()
# request.actor_ = message.actor_
# request.playing_template_ = message.template_
request.playing_ = message.playing_
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INCREASE_COMPLETE,\
request)
proxy.Timer.add(message.playing_,
slime_types.Config.get_slime_time() * 1000, 1,
"playing_slime_on_timer_slime")
# 副本管理器中建立一个玩家ID和副本ID的映射关系
slime_types.PlayingManager.add_actor(message.actor_, message.playing_)
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - playing.get_start_time()
# datas = [剩余体力, 阶段, 当前阶段剩余时间]
request.datas_ = []
request.datas_.append(slime_types.Config.get_max_power() -
playing.get_spend_power())
if playing.get_section_boss() == True:
request.datas_.append(2)
request.datas_.append(now - playing.get_boss_summon_time())
else:
request.datas_.append(1)
# 第一阶段剩下的时间
elapse_time = now - playing.get_start_time()
if elapse_time <= slime_types.Config.get_slime_time():
request.datas_.append(slime_types.Config.get_slime_time() -
elapse_time)
else:
request.datas_.append(0)
request.scores_ = []
request.scores_.append(ccentity.playing.ttypes.PlayingScoreField(\
ccentity.playing.ttypes.PlayingScoreType.KILL_NPC, 0, playing.get_score()))
request.scores_.append(ccentity.playing.ttypes.PlayingScoreField(\
ccentity.playing.ttypes.PlayingScoreType.POWER, 0,\
slime_types.Config.get_max_power() - playing.get_spend_power()))
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR,\
request)
# 转为临时技能形态
facade_request.change_skill_form(ccentity.entity.ttypes.EntityType.TYPE_ACTOR,\
message.actor_, ccentity.skill.ttypes.SkillFormType.TEMP)
# 增加临时技能
facade_request.add_temp_skill(ccentity.entity.ttypes.EntityType.TYPE_ACTOR,\
message.actor_, 100, 1)
facade_request.add_temp_skill(ccentity.entity.ttypes.EntityType.TYPE_ACTOR,\
message.actor_, 200, 1)
facade_request.add_temp_skill(ccentity.entity.ttypes.EntityType.TYPE_ACTOR,\
message.actor_, 300, 1)
proxy.Logging.debug("[slime] actor(%d) enter into playing" %
message.actor_)
def playing_monsters_on_event_playing_actor_enter(message_type, channel, channel_type, serialize):
# 事件消息
message = ccevent.playing.ttypes.EventPlayingActorEnter()
# 反序列化
TSerialization.deserialize(message, serialize)
# 关注玩家杀死NPC事件、请求完成副本事件
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_ACTOR_KILL_NPC,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_monsters_on_event_actor_kill_npc")
proxy.Communicator.follow(ccevent.ttypes.EventType.EVENT_PLAYING_ACTOR_REQUEST_COMPLETE,\
message.actor_, ccevent.ttypes.ChannelType.CHANNEL_ACTOR,\
"playing_monsters_on_event_playing_actor_request_complete")
playing = monsters_types.PlayingManager.get(message.playing_)
if playing == None:
return None
now = time.time()
actor = playing.get_actor()
if actor == 0:
playing.set_start_time(now)
playing.set_actor(message.actor_)
# 消耗玩家副本次数
request = ccrequest.playing.ttypes.RequestPlayingIncreaseComplete()
request.actor_ = message.actor_
request.playing_template_ = message.template_
# 发送请求
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INCREASE_COMPLETE,\
request)
proxy.Timer.add(message.playing_, monsters_types.Config.get_playing_time(),\
1, "playing_monsters_on_timer_playing_time")
# 副本管理器中建立一个玩家ID和副本ID的映射关系
monsters_types.PlayingManager.add_actor(message.actor_, message.playing_)
# 请求初始化玩家
request = ccrequest.playing.ttypes.RequestPlayingInitializeActor()
request.actor_ = message.actor_
request.spend_time_ = now - playing.get_start_time()
########################################
# TODO: 考虑做为分数进行同步
# datas = [祭坛1(0为未完成1为完成)+祭坛2+祭坛3+祭坛4+祭坛5+祭坛6]
request.datas_ = []
cages = playing.get_cages()
for i in range(0, len(cages)):
if cages[i].get_current_round() < cages[i].get_max_round():
request.datas_.append(0)
else:
request.datas_.append(1)
########################################
request.scores_ = []
# 循环获取玩家杀死的每个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);
proxy.Request.request(ccrequest.ttypes.RequestType.REQUEST_PLAYING_INITIALIZE_ACTOR,\
request)
proxy.Logging.debug("[monsters] actor(%d) enter into playing" % message.actor_)
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_))
