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_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 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_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_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_))