You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4204 lines
146 KiB
4204 lines
146 KiB
GuildModel = GuildModel or BaseClass(BaseModel)
|
|
|
|
-- 旧协议，但是还有用的
|
|
GuildModel.REQUEST_CCMD_EVENT = "GuildModel.REQUEST_CCMD_EVENT" -- 请求社团协议事件
|
|
GuildModel.UPDATE_RED_DOT_BY_TYPE = "GuildModel.UPDATE_RED_DOT_BY_TYPE" -- 刷新社团系统全局红点(根据界面类型)
|
|
GuildModel.RequestGuildListEvt = "GuildModel.RequestGuildListEvt" --请求社团列表事件
|
|
GuildModel.RefreshGuildListEvt = "GuildModel.RefreshGuildListEvt" --刷新社团列表事件
|
|
GuildModel.ApplyJoinGuildEvt = "GuildModel.ApplyJoinGuildEvt" --申请加入社团
|
|
GuildModel.RequestMultiJoinGuildEvt = "GuildModel.RequestMultiJoinGuildEvt" --请求海投简历
|
|
GuildModel.RequestCreateGuildEvt = "GuildModel.RequestCreateGuildEvt" --请求创建社团
|
|
GuildModel.RequestGuildBaseInfoEvt = "GuildModel.RequestGuildBaseInfoEvt" --请求社团基础信息
|
|
GuildModel.RefreshGuildInfoEvt = "GuildModel.RefreshGuildInfoEvt" --刷新社团主页基础信息
|
|
GuildModel.RefreshMainViewMemberInfoEvt = "GuildModel.RefreshMainViewMemberInfoEvt" --刷新社团主界面请求成员信息
|
|
GuildModel.RequestMemberViewMemberInfoEvt = "GuildModel.RequestMemberViewMemberInfoEvt" --请求成员界面成员信息
|
|
GuildModel.RefreshMemberApplyListEvt = "GuildModel.RefreshMemberApplyListEvt" --刷新成员申请信息
|
|
GuildModel.RequestQuitGuildEvt = "GuildModel.RequestQuitGuildEvt" --请求退出社团
|
|
GuildModel.RequestSetApplyMemberStateEvt = "GuildModel.RequestSetApplyMemberStateEvt" --请求设置玩家的申请状态
|
|
GuildModel.RefreshtSetApplyMemberStateEvt = "GuildModel.RefreshtSetApplyMemberStateEvt" --更新设置玩家的申请状态
|
|
GuildModel.RefreshApplySettingViewStateEvt = "GuildModel.RefreshApplySettingViewStateEvt" --刷新申请设置界面的状态
|
|
GuildModel.RequestApplySettingConditionEvt = "GuildModel.RequestApplySettingConditionEvt" --请求申请设置界面条件
|
|
GuildModel.RequestSetAnnounceEvt = "GuildModel.RequestSetAnnounceEvt" --请求设置公告
|
|
GuildModel.RefreshGuildAnnounceEvt = "GuildModel.RefreshGuildAnnounceEvt" --刷新主界面公告
|
|
GuildModel.RequestAgreeApplyListEvt = "GuildModel.RequestAgreeApplyListEvt" --同意申请列表
|
|
GuildModel.RefreshPostNumEvt = "GuildModel.RefreshPostNumEvt" --刷新职位数量
|
|
GuildModel.RequestAppointMemberPostEvt = "GuildModel.RequestAppointMemberPostEvt" --任命职位
|
|
GuildModel.RequestKickOutGuildEvt = "GuildModel.RequestKickOutGuildEvt" --请求踢出社团
|
|
GuildModel.RefreshKickOutGuildEvt = "GuildModel.RefreshKickOutGuildEvt" --刷新踢出社团
|
|
GuildModel.RefreshPermissionListEvt = "GuildModel.RefreshPermissionListEvt" --刷新玩家权限列表
|
|
GuildModel.UPDATE_GOODS_LIST = "GuildModel.UPDATE_GOODS_LIST" --刷新社团商店列表信息
|
|
GuildModel.RefreshBuyGoodsItemEvt = "GuildModel.RefreshBuyGoodsItemEvt" --更新购买goodsitem数量信息事件
|
|
GuildModel.UPDATE_GUILDACTIVE_RANK_DATA = "GuildModel.UPDATE_GUILDACTIVE_RANK_DATA" -- 从排行榜模块获取活跃度社团排行信息
|
|
GuildModel.OPEN_GUILD_EVENT_VIEW = "GuildModel.OPEN_GUILD_EVENT_VIEW" --跳转到指定活动界面
|
|
GuildModel.AFTER_GET_HISTORY_GUILD_COUNT = "GuildModel.AFTER_GET_HISTORY_GUILD_COUNT" --查询社团历史最大数量后
|
|
|
|
--本服团战
|
|
GuildModel.OPEN_GUILD_WAR_SCENE_VIEW = "GuildModel.OPEN_GUILD_WAR_SCENE_VIEW" --本服团战场景界面
|
|
GuildModel.OPEN_GUILD_WAR_RANK_VIEW = "GuildModel.OPEN_GUILD_WAR_RANK_VIEW" --本服团战场排行
|
|
GuildModel.ENTER_GUILD_WAR_SCENE = "GuildModel.ENTER_GUILD_WAR_SCENE" --进入本服团战场景
|
|
GuildModel.LEAVE_GUILD_WAR_SCENE = "GuildModel.LEAVE_GUILD_WAR_SCENE" --离开本服团战场景
|
|
GuildModel.GUILD_WAR_LAST_MVP = "GuildModel.GUILD_WAR_LAST_MVP" --上期明星团长
|
|
GuildModel.GUILD_WAR_RANK_LIST = "GuildModel.GUILD_WAR_RANK_LIST" --本服团战排行数据
|
|
GuildModel.GUILD_WAR_RESULT = "GuildModel.GUILD_WAR_RESULT" --大战结果
|
|
GuildModel.GUILD_WAR_UPDATE_SCROE = "GuildModel.GUILD_WAR_UPDATE_SCROE" --大战积分刷新
|
|
GuildModel.GUILD_WAR_BASE_INFO = "GuildModel.GUILD_WAR_BASE_INFO" --大战基本信息
|
|
GuildModel.GUILD_WAR_PICK_STATE = "GuildModel.GUILD_WAR_PICK_STATE" --采集状态变化
|
|
GuildModel.GUILD_WAR_BOSS_BORN = "GuildModel.GUILD_WAR_BOSS_BORN" --boss出生
|
|
GuildModel.GUILD_WAR_BOSS_DIE = "GuildModel.GUILD_WAR_BOSS_DIE" --boss死亡
|
|
GuildModel.GUILD_WAR_OPEN_STATE = "GuildModel.GUILD_WAR_OPEN_STATE" --开放情况
|
|
GuildModel.GUILD_WAR_START_COLLECT = "GuildModel.GUILD_WAR_START_COLLECT" --开始采集
|
|
GuildModel.GUILD_WAR_PROJECT = "GuildModel.GUILD_WAR_PROJECT" --护盾
|
|
GuildModel.OPEN_SELECT_SERVER = "GuildModel.OPEN_SELECT_SERVER" --战区选择
|
|
|
|
GuildModel.OPEN_ACTIVE_OPEN_TIPS_VIEW = "GuildModel.OPEN_ACTIVE_OPEN_TIPS_VIEW" --打开战场开启界面
|
|
GuildModel.SHOW_ACTIVE_OPEN_TIPS_RED = "GuildModel.SHOW_ACTIVE_OPEN_TIPS_RED" --显示战场开启红点
|
|
|
|
|
|
|
|
-- 社团驻地和社团活动协议相关
|
|
GuildModel.ENTER_GUILD_BASE = "GuildModel.ENTER_GUILD_BASE" --前往社团驻地
|
|
GuildModel.LEAVE_GUILD_BASE = "GuildModel.LEAVE_GUILD_BASE" --离开社团驻地
|
|
|
|
GuildModel.UPDATE_GUILD_EVENT_BY_TYPE = "GuildModel.UPDATE_GUILD_EVENT_BY_TYPE" --根据类型更新社团活动数据
|
|
|
|
GuildModel.UPDATE_GUILD_COLLECT_LEFT_TIME = "GuildModel.UPDATE_GUILD_COLLECT_LEFT_TIME" -- 刷新采集活动倒计时
|
|
GuildModel.UPDATE_GUILD_COLLECT_INFO_CON = "GuildModel.UPDATE_GUILD_COLLECT_INFO_CON" -- 刷新采集活动右上角信息栏
|
|
GuildModel.UODATE_GUILD_COLLECT_ACTIVITY_TIMES = "GuildModel.UODATE_GUILD_COLLECT_ACTIVITY_TIMES" -- 刷新活动界面的采集参加次数
|
|
GuildModel.UPDATE_GUILD_COLLECT_LEFT_COLLECT_MON_NUM = "GuildModel.UPDATE_GUILD_COLLECT_LEFT_COLLECT_MON_NUM"--刷新当前剩余的采集怪数量
|
|
GuildModel.OPEN_GUILD_COLLECT_REWARD_VIEW = "GuildModel.OPEN_GUILD_COLLECT_REWARD_VIEW"--打开封印裂隙奖励说明界面
|
|
GuildModel.ANS_GUILD_COLLECT_HELP_LIST = "GuildModel.ANS_GUILD_COLLECT_HELP_LIST"--刷新封印裂隙协助信息
|
|
GuildModel.CHANGE_GUILD_COLLECT_LEFT_CON_STATE = "GuildModel.CHANGE_GUILD_COLLECT_LEFT_CON_STATE"--切换封印裂隙左上角
|
|
GuildModel.FIND_WAY_TO_GUILD_COLLECT_HELP_MON = "GuildModel.FIND_WAY_TO_GUILD_COLLECT_HELP_MON"--寻路去杀协助的入侵怪
|
|
GuildModel.AUTO_FIND_WAY_TO_GUILD_COLLECT_MON = "GuildModel.AUTO_FIND_WAY_TO_GUILD_COLLECT_MON"--自动寻路去采集最近的裂隙
|
|
GuildModel.UPDATE_AUTO_GUILD_COLLECT_STATE = "GuildModel.UPDATE_AUTO_GUILD_COLLECT_STATE"--更新自动采集状态
|
|
GuildModel.GUILD_COLLECT_SUPPORT_CANCEL = "GuildModel.GUILD_COLLECT_SUPPORT_CANCEL"--封印裂隙取消事件
|
|
GuildModel.UPDATE_GUILD_COLLECT_SUPPORT_INFO_LIST = "UPDATE_GUILD_COLLECT_SUPPORT_INFO_LIST"--封印裂隙协助列表刷新
|
|
GuildModel.UPDATE_GUILD_COLLECT_NOW_SUPPORT_ID = "GuildModel.UPDATE_GUILD_COLLECT_NOW_SUPPORT_ID"--刷新当前的封印裂隙协助id
|
|
|
|
GuildModel.UPDATE_GUILD_BOSS_RANK = "GuildModel.UPDATE_GUILD_BOSS_RANK" -- 更新社团boss输出排行
|
|
GuildModel.UPDATE_GUILD_BOSS_PERSONAL_RANK = "GuildModel.UPDATE_GUILD_BOSS_PERSONAL_RANK" -- 更新社团boss个人输出信息
|
|
GuildModel.UPDATE_GUILDBOSS_INVINCIBLE = "GuildModel.UPDATE_GUILDBOSS_INVINCIBLE" -- 更新社团boss狂暴信息
|
|
|
|
GuildModel.UPDATE_GUILDPARTY_EXPDATA = "GuildModel.UPDATE_GUILDPARTY_EXPDATA" -- 更新社团派对经验信息
|
|
-- GuildModel.CHANGE_GUILDDANCE_ACTION = "GuildModel.CHANGE_GUILDDANCE_ACTION" -- 切换社团祝火跳舞动作
|
|
GuildModel.UPDATE_GUILD_ANNOUNCE_TIMES = "GuildModel.UPDATE_GUILD_ANNOUNCE_TIMES" -- 更新社团公告修改次数信息
|
|
GuildModel.UPDATE_GUILD_SCENE_MEMBER_NUM = "GuildModel.UPDATE_GUILD_SCENE_MEMBER_NUM" -- 社团驻地内人数协议
|
|
|
|
-- 社团界面相关逻辑
|
|
GuildModel.OPEN_GUILD_EDITOR_ANNOUNCE_VIEW = "GuildModel.OPEN_GUILD_EDITOR_ANNOUNCE_VIEW" -- 打开编辑社团公告界面
|
|
GuildModel.OPEN_POSITION_APPLY_VIEW = "GuildModel.OPEN_POSITION_APPLY_VIEW" -- 打开社团合并界面
|
|
GuildModel.UPDATE_MEMBER_VIEW_RED = "GuildModel.UPDATE_MEMBER_VIEW_RED" -- 刷新社团成员管理界面红点
|
|
GuildModel.UPDATE_ROLE_ACTIVE_DATA = "GuildModel.UPDATE_ROLE_ACTIVE_DATA" -- 更新社团个人活跃数据
|
|
GuildModel.UPDATE_GUILD_TASK_PROGRESS = "GuildModel.UPDATE_GUILD_TASK_PROGRESS" -- 更新社团活跃任务数据
|
|
GuildModel.UPDATE_GUILD_ACTIVE_DATA = "GuildModel.UPDATE_GUILD_ACTIVE_DATA" -- 更新社团周活跃数据
|
|
GuildModel.UPDATE_GUILD_ACTIVE_REWARD = "GuildModel.UPDATE_GUILD_ACTIVE_REWARD" -- 更新社团活跃奖励领取
|
|
GuildModel.UPDATE_ACTIVE_RED = "GuildModel.UPDATE_ACTIVE_RED" -- 刷新社团活跃奖励红点
|
|
GuildModel.OPEN_GUILD_LOG_VIEW = "GuildModel.OPEN_GUILD_LOG_VIEW" -- 打开社团合并界面
|
|
GuildModel.UPDATE_GUILD_LOG = "GuildModel.UPDATE_GUILD_LOG" -- 更新社团日志
|
|
GuildModel.UPDATE_GUILD_MERGE_INFO = "GuildModel.UPDATE_GUILD_MERGE_INFO" -- 更新社团合并信息
|
|
GuildModel.OPEN_GUILD_BOSS_VIEW = "GuildModel.OPEN_GUILD_BOSS_VIEW" -- 打开社团午间boss活动界面
|
|
GuildModel.OPEN_GUILD_SUPPORT_IFNO_VIEW = "GuildModel.OPEN_GUILD_SUPPORT_IFNO_VIEW" -- 打开社团协助信息界面
|
|
GuildModel.CLOSE_GUILD_SUPPORT_IFNO_VIEW = "GuildModel.CLOSE_GUILD_SUPPORT_IFNO_VIEW" --关闭协助信息界面
|
|
GuildModel.OPEN_GUILD_SUPPORT_THANK_VIEW = "GuildModel.OPEN_GUILD_SUPPORT_THANK_VIEW" -- 打开社团协助感谢界面
|
|
GuildModel.SHOW_GUILD_SUPPORT_THANK_BTN = "GuildModel.SHOW_GUILD_SUPPORT_THANK_BTN" --展示社团协助按钮
|
|
GuildModel.UPDATE_GUILD_SUPPOR_INFO = "GuildModel.UPDATE_GUILD_SUPPOR_INFO"--更新社团协助信息
|
|
GuildModel.BOARD_GUILD_SUPPOR_REMOVE = "GuildModel.BOARD_GUILD_SUPPOR_REMOVE"--社团协助成员取消协助
|
|
GuildModel.UPDATE_GUILD_SUPPOR_THANK_INFO = "GuildModel.UPDATE_GUILD_SUPPOR_THANK_INFO"--更新社团协助感谢信息
|
|
GuildModel.UPDATE_GUILD_SUPPOR_THANK_DESC = "GuildModel.UPDATE_GUILD_SUPPOR_THANK_DESC"--更新社团协助感谢说明
|
|
GuildModel.OPEN_GUILD_SUPPORT_GO_VIEW = "GuildModel.OPEN_GUILD_SUPPORT_GO_VIEW"--打开社团协助前往界面
|
|
GuildModel.OPEN_GUILD_SUPPORT_RESULT_VIEW = "GuildModel.OPEN_GUILD_SUPPORT_RESULT_VIEW"--打开社团协助结算界面
|
|
GuildModel.UPDATE_SUPPORT_THANK_LIST = "GuildModel.UPDATE_SUPPORT_THANK_LIST"--更新协助感谢列表
|
|
GuildModel.UPDATE_SUPPORT_GIFT_LIST = "GuildModel.UPDATE_SUPPORT_GIFT_LIST"--更新协助感谢领奖列表
|
|
GuildModel.OPEN_GUILD_SUPPORT_TIP_VIEW = "GuildModel.OPEN_GUILD_SUPPORT_TIP_VIEW"--快捷发送界面
|
|
GuildModel.CLOSE_GUILD_SUPPORT_TIP_VIEW = "GuildModel.CLOSE_GUILD_SUPPORT_TIP_VIEW"--关闭快捷发送界面
|
|
GuildModel.OPEN_GUILD_SUPPORT_ACCEPT_VIEW = "GuildModel.OPEN_GUILD_SUPPORT_ACCEPT_VIEW"--打开社团协助任务获取界面
|
|
GuildModel.OPEN_GUILD_SUPPORT_GUILD_BOSS_GO_VIEW = "GuildModel.OPEN_GUILD_SUPPORT_GUILD_BOSS_GO_VIEW"--打开社团协助BOSS前往界面
|
|
GuildModel.OPEN_REQUEST_MERGE_VIEW = "GuildModel.OPEN_REQUEST_MERGE_VIEW" -- 打开社团合并发起界面
|
|
|
|
|
|
GuildModel.OPEN_GUILD_BOSS_RESULT_VIEW = "GuildModel.OPEN_GUILD_BOSS_RESULT_VIEW" -- 打开社团boss结算界面
|
|
GuildModel.OPEN_GUILD_POS_ALLOT_VIEW = "GuildModel.OPEN_GUILD_POS_ALLOT_VIEW" -- 打开社团职位任命界面
|
|
GuildModel.OPEN_GUILD_APPLY_MGR_VIEW = "GuildModel.OPEN_GUILD_APPLY_MGR_VIEW" -- 打开社团申请管理界面
|
|
GuildModel.OPEN_GUILD_RENAME_VIEW = "GuildModel.OPEN_GUILD_RENAME_VIEW" -- 打开改名该标志界面
|
|
---- 拼单新事件
|
|
GuildModel.UPDATE_GUILD_SL_DATA = "GuildModel.UPDATE_GUILD_SL_DATA" -- 更新拼单数据
|
|
GuildModel.UPDATE_SELECTED_GUILD_SL_DATA = "GuildModel.UPDATE_SELECTED_GUILD_SL_DATA" -- 更新当前选中拼单数据
|
|
GuildModel.OPEN_GUILD_SL_REWARD_VIEW = "GuildModel.OPEN_GUILD_SL_REWARD_VIEW" -- 打开社团拼单奖励界面
|
|
GuildModel.OPEN_GUILD_SL_THANK_VIEW = "GuildModel.OPEN_GUILD_SL_THANK_VIEW" -- 打开社团拼单感谢界面
|
|
----
|
|
GuildModel.PICK_UP_BOSS_DROP_ITEM = "GuildModel.PICK_UP_BOSS_DROP_ITEM" -- 发送社团boss采集协议
|
|
GuildModel.UPDATE_GUILD_BOSS_INFO = "GuildModel.UPDATE_GUILD_BOSS_INFO" -- 更新社团boss状态（社团boss掉落专用）
|
|
GuildModel.START_TO_COLLECT_ITEM = "GuildModel.START_TO_COLLECT_ITEM" -- 社团boss开始采集
|
|
GuildModel.STOP_COLLECT_ITEM = "GuildModel.STOP_COLLECT_ITEM" -- 社团boss中断采集
|
|
GuildModel.PICK_SCENE_DROP_ITEM = "GuildModel.PICK_SCENE_DROP_ITEM" -- 社团boss采集成功
|
|
GuildModel.GUILD_BOSS_DROP_EVENT = "GuildModel.GUILD_BOSS_DROP_EVENT" -- 社团boss掉落事件
|
|
GuildModel.OPEN_BOSS_ROLL_VIEW = "GuildModel.OPEN_BOSS_ROLL_VIEW" -- 打开社团bossroll点界面
|
|
GuildModel.UPDATE_BOSS_ROLL_DATA = "GuildModel.UPDATE_BOSS_ROLL_DATA" -- 更新社团bossroll点界面
|
|
GuildModel.UPDATE_BOSS_ROLL_RECORD = "GuildModel.UPDATE_BOSS_ROLL_RECORD" -- 更新社团bossroll点记录
|
|
GuildModel.UPDATE_GUILD_BOSS_HIGHEST_DATA = "GuildModel.UPDATE_GUILD_BOSS_HIGHEST_DATA" -- 更新社团bossroll点最高记录
|
|
GuildModel.UPDATE_SCENE_FUNCBTN_NUM_RED = "GuildModel.UPDATE_SCENE_FUNCBTN_NUM_RED" -- 更新场景功能按钮的次数红点
|
|
GuildModel.OPEN_BOSS_ROLL_PREVIEW_VIEW = "GuildModel.OPEN_BOSS_ROLL_PREVIEW_VIEW" -- 打开社团boss奖励预览界面
|
|
|
|
GuildModel.OPEN_CSGR_SCENE_VIEW = "GuildModel.OPEN_CSGR_SCENE_VIEW" -- 打开本国团战活动场景界面
|
|
GuildModel.OPEN_CSGR_REWARD_VIEW = "GuildModel.OPEN_CSGR_REWARD_VIEW" -- 打开本国团战奖励预览界面
|
|
GuildModel.OPEN_CSGR_RANK_VIEW = "GuildModel.OPEN_CSGR_RANK_VIEW" -- 打开本国团战伤害排行界面
|
|
GuildModel.OPEN_CSGR_FIGHTINFO_VIEW = "GuildModel.OPEN_CSGR_FIGHTINFO_VIEW" -- 打开本国团战对战信息界面
|
|
GuildModel.UPDATE_CSGR_FIGHTINFO = "GuildModel.UPDATE_CSGR_FIGHTINFO" -- 更新本国团战对战信息
|
|
GuildModel.UPDATE_CSGR_COLLECTBUFF = "GuildModel.UPDATE_CSGR_COLLECTBUFF" -- 更新本国团战采集buff信息
|
|
GuildModel.UPDATE_CSGR_BF_RES = "GuildModel.UPDATE_CSGR_BF_RES" -- 更新本国团战战场资源信息
|
|
GuildModel.UPDATE_CSGR_DMG_RANK = "GuildModel.UPDATE_CSGR_DMG_RANK" -- 更新本国团战输出排行（二级界面）
|
|
GuildModel.UPDATE_CSGR_SCENE_DMG_RANK = "GuildModel.UPDATE_CSGR_SCENE_DMG_RANK" -- 更新本国团战输出排行（活动场景内）
|
|
GuildModel.OPEN_CSGR_RESULT_VIEW = "GuildModel.OPEN_CSGR_RESULT_VIEW" -- 打开本国团战结算界面
|
|
GuildModel.UPDATE_CSGR_BOSS_HP = "GuildModel.UPDATE_CSGR_BOSS_HP" -- 本国团战boss血条推送
|
|
|
|
-- 社团跑环答题
|
|
GuildModel.UPDATE_QUIZ_VIEW_ANSWERING = "GuildModel.UPDATE_QUIZ_VIEW_ANSWERING" -- 更新题目
|
|
GuildModel.UPDATE_QUIZ_VIEW_SHOWING = "GuildModel.UPDATE_QUIZ_VIEW_SHOWING" -- 更新答案展示
|
|
GuildModel.OPEN_GUILD_QUIZ_VIEW = "GuildModel.OPEN_GUILD_QUIZ_VIEW" -- 打开答题界面
|
|
GuildModel.OPEN_GUILD_QUIZ_RESULT_VIEW = "GuildModel.OPEN_GUILD_QUIZ_RESULT_VIEW" -- 打开答题界面
|
|
GuildModel.GUILD_QUIZ_FINISH = "GuildModel.GUILD_QUIZ_FINISH" -- 答题结束了
|
|
|
|
GuildModel.UPDATE_SUPPORT_GUILD_INFO = "GuildModel.UPDATE_SUPPORT_GUILD_INFO" -- 虚空副本信息
|
|
--------------------------------------------------
|
|
-- 社团职位id GuildModel.GuildPosition.Leader
|
|
GuildModel.GuildPosition = {
|
|
Leader = 1, --会长
|
|
ViceLeader = 2,--副会长
|
|
Elite = 3, --战斗精英
|
|
Teasure = 4, --活宝
|
|
Normal = 5, --成员
|
|
Agency = 6, --代理社长
|
|
-- EnterGuild = 66, --进入社团
|
|
}
|
|
-- 社团管理权限 GuildModel.MgrPermission.ChangeAnnounce
|
|
GuildModel.MgrPermission = {
|
|
PassJoinApply = 1, -- 通过加入申请
|
|
PassPosApply = 2, -- 通过职位申请
|
|
KickMember = 3, -- 剔除社团成员
|
|
ChangeAnnounce = 4, -- 修改社团公告
|
|
ChangeApplySetting = 5, -- 修改社团申请设置
|
|
ChangeName = 6, -- 社团改名
|
|
MergeGuild = 7, -- 社团合并
|
|
}
|
|
-- 社团日志类型 GuildModel.LogType.Join
|
|
GuildModel.LogType = {
|
|
Join = 1, -- 1.玩家加入
|
|
Active = 2, -- 2.玩家活跃记录
|
|
Position = 3, -- 3.职位变更
|
|
Upgrade = 4, -- 4.社团升级
|
|
}
|
|
|
|
-- 社团日志模板
|
|
GuildModel.LogStr = {
|
|
[GuildModel.LogType.Join] = "欢迎 <color=#2cf86f>@name</color> 玩家加入本社团，与大家一起建设社团大家庭",
|
|
[GuildModel.LogType.Active] = "<color=#2cf86f>@name</color> 为社团贡献了 <color=#2cf86f>@active</color> 点活跃值，为社团成长添砖加瓦！",
|
|
[GuildModel.LogType.Position] = "社团成员 <color=#2cf86f>@name</color> 玩家职位变更为 <color=#fdffc2>@pos</color> ，以更好地为社团贡献自己的力量",
|
|
[GuildModel.LogType.Upgrade] = "本社团等级提升至 <color=#2cf86f>@upgrade级</color> ，大家的努力有了成效，这一刻的荣耀属于每一个人！",
|
|
}
|
|
|
|
-- 社团商城购买类型 GuildModel.ShopBuyType.NoLimit
|
|
GuildModel.ShopBuyType = {
|
|
NoLimit = 0, -- 不限购
|
|
DayLimit = 1, -- 日限购
|
|
WeekLimit = 2, -- 周限购
|
|
RoleLimit = 3, -- 终生限购
|
|
}
|
|
---------------------------------------------------------
|
|
GuildModel.EXP_GOODS_ID = 38040201
|
|
GuildModel.GuildContributeId = 100004 -- 社团贡献道具id
|
|
GuildModel.GuildContributeType = 8 -- 社团贡献道具货币类型
|
|
|
|
--协助状态
|
|
GuildModel.SupportType = {
|
|
Thank = 1, -- 感谢
|
|
Award = 2, -- 领奖
|
|
}
|
|
|
|
GuildModel.SupportTab = {
|
|
List = 1, -- 列表界面
|
|
Thank = 2, -- 感谢列表
|
|
Gift = 3, -- 收下感谢
|
|
}
|
|
|
|
-- 社团拼单文字说明
|
|
GuildModel.SupportTypeStr = {
|
|
[1] = "协助击杀",
|
|
[2] = "协助击杀",
|
|
[3] = "协助完成",
|
|
[4] = "协助击杀",
|
|
[5] = "协助",
|
|
[6] = "协助",
|
|
}
|
|
|
|
GuildModel.SpellListColor = {
|
|
[1] = "#66abff",
|
|
[2] = "#f558ff",
|
|
[3] = "#feb940",
|
|
}
|
|
-- 需要展示在【活动】界面的【限时活动】都需要配置键值在这里,值为界面节点名称
|
|
GuildModel.EventModuleId = {
|
|
["406@1"] = "GuildEventBossView", -- 社团午间boss
|
|
["406@2"] = "GuildEventBossView", -- 社团晚间boss
|
|
["408@0"] = "GuildEventCollectView", -- 社团午间采集
|
|
["400@7"] = "GuildEventPartyView", -- 社团派对
|
|
["405@1"] = "GuildEventWarView", -- 本服团战
|
|
["410@1"] = "GuildEventCSGuildRankView", -- 本国团战
|
|
["410@2"] = "GuildEventCSGuildRankView", -- 本国团战
|
|
}
|
|
-- EventView的页签加载图片
|
|
GuildModel.EventTabRes = {
|
|
["406@1"] = "guild_event_406_1_pointfilter", -- 社团午间boss
|
|
["406@2"] = "guild_event_406_1_pointfilter", -- 社团晚间boss
|
|
["408@0"] = "guild_event_408_0_pointfilter", -- 社团午间采集
|
|
["400@7"] = "guild_event_400_7_pointfilter", -- 社团派对
|
|
["405@1"] = "guild_event_405_1_pointfilter", -- 本服团战
|
|
["410@1"] = "guild_event_410_1_pointfilter", -- 本国团战
|
|
["410@2"] = "guild_event_410_2_pointfilter", -- 本国团战
|
|
}
|
|
|
|
-- 社团活动玩法类型（前端用）
|
|
GuildEventType = {
|
|
NoonCollect = 4080, -- 午间采集
|
|
GuildBossNoon = 4061,
|
|
GuildBossNight = 4062,
|
|
GuildParty = 4007, -- 社团派对
|
|
GuildTV = 1420, -- 跑马
|
|
GuildWar = 4051, -- 跑马
|
|
GuildCSGR = 410, -- 本国团战
|
|
}
|
|
|
|
-- 社团活动玩法可预告玩法类型,值为按钮图标资源
|
|
GuildTrailerEventType = {
|
|
[GuildEventType.GuildBossNoon] = "icon_406_0",
|
|
[GuildEventType.GuildBossNight] = "icon_406_0",
|
|
[GuildEventType.NoonCollect] = "icon_408_0",
|
|
[GuildEventType.GuildParty] = "icon_400_7",
|
|
-- [GuildEventType.GuildWar] = "icon_405_1",
|
|
-- [GuildEventType.GuildCSGR] = "icon_rightTop_410",
|
|
}
|
|
-- 社团午间/晚间boss排行类型
|
|
GuildBossRankType = {
|
|
Personal = 0,
|
|
Guild = 1,
|
|
}
|
|
-- 社团活动中允许多个时间段存在的活动
|
|
GuildModel.AllowRepeatEvent = {
|
|
[406] = true,
|
|
[408] = true,
|
|
}
|
|
GuildModel.GuildBossId = 651001 -- 社团bossid
|
|
GuildModel.GuildCollectMonId = 650001 -- 封印裂隙怪物id
|
|
GuildModel.GuildCollectModuleId = 408 --社团采集对应模块id
|
|
GuildModel.FEAST_MONSTER_INSTANCE_ID = 1 -- 社团派对中间客户端怪物id
|
|
GuildModel.GuildPowerRankType = 407 -- 社团合并界面的排行请求类型
|
|
GuildModel.GuildActiveRankType = 4002 -- 社团合并界面的排行请求类型
|
|
-- 社团协助感谢言语
|
|
GuildModel.ThankDesc = {
|
|
[1] = "请大佬喝阔乐",
|
|
[2] = "给大佬递茶",
|
|
[3] = "一键三连",
|
|
[4] = "送大佬一个火箭",
|
|
}
|
|
-- 社团权限描述
|
|
GuildModel.PermissionStr = {
|
|
[GuildModel.MgrPermission.PassJoinApply] = "审批入团申请",
|
|
[GuildModel.MgrPermission.PassPosApply] = "审批职位申请",
|
|
[GuildModel.MgrPermission.KickMember] = "踢出团员",
|
|
[GuildModel.MgrPermission.ChangeAnnounce] = "修改社团宣言",
|
|
[GuildModel.MgrPermission.ChangeApplySetting] = "修改社团申请设置",
|
|
[GuildModel.MgrPermission.ChangeName] = "修改社团名称",
|
|
[GuildModel.MgrPermission.MergeGuild] = "管理社团合并",
|
|
}
|
|
-- 社团职位申请节点的职位描述
|
|
GuildModel.PosApplyDesc = {
|
|
[GuildModel.GuildPosition.ViceLeader] =
|
|
{
|
|
"审批入团申请",
|
|
"审批职位申请",
|
|
"踢出团员",
|
|
"修改社团公告",
|
|
"修改社团申请设置",
|
|
},
|
|
[GuildModel.GuildPosition.Elite] = {"该职务暂无权限"},
|
|
[GuildModel.GuildPosition.Teasure] = {"该职务暂无权限"},
|
|
}
|
|
-- 社团boss采集操作类型
|
|
GuildModel.GBossPickOpty = {
|
|
Start = 0,
|
|
Succeed = 1,
|
|
Cancel = 2,
|
|
}
|
|
|
|
-- 本服团战 寻找目标
|
|
GuildModel.GuildWarTarget = {
|
|
Boss = 653001, --boss
|
|
SmallRice = 653002, --粗粮
|
|
BigRice = 653003, --精粮
|
|
MiddleRice = 653004, --中粮
|
|
Npc = 99999999, --npc的集合
|
|
Npc_1 = 410001, --采集任务提交NPC1
|
|
Npc_2 = 410002, --采集任务提交NPC2
|
|
Npc_3 = 410003, --采集任务提交NPC3
|
|
}
|
|
|
|
-- 本服团战 跟随模型id
|
|
GuildModel.GuildWarModelRes = {
|
|
SmallRice = 10020202, --粗粮
|
|
MiddleRice = 10020202, --中粮
|
|
BigRice = 10020202, --精粮
|
|
}
|
|
|
|
-- 本服团战 跟随模型 缩放比例
|
|
GuildModel.GuildWarModelResScale =
|
|
{
|
|
--模型id --缩放比例
|
|
[10020202] = 1.6,
|
|
[10020202] = 1.6,
|
|
[10020202] = 1.6,
|
|
}
|
|
|
|
-- 本国团战对战信息类型
|
|
GuildModel.CSGRRankType = {
|
|
Mine = 0,
|
|
All = 1
|
|
}
|
|
-- 本国团战排行分页大小
|
|
GuildModel.RankPageSize = 10
|
|
GuildModel.FightInfoPageSize = 10
|
|
-- 本国团战专用属性描述
|
|
GuildModel.CSGRAttrName = {
|
|
[19] = "攻击",
|
|
[25] = "暴击",
|
|
[54] = "会心",
|
|
[27] = "技伤",
|
|
}
|
|
-- 社团本国团战中，右侧团员采集信息的颜色配置
|
|
GuildModel.CSGRCollectTipsColorCfg = {
|
|
[19] = ColorUtil.YELLOW_DARK,
|
|
[25] = ColorUtil.RED_DARK,
|
|
[54] = ColorUtil.BLUE_DARK,
|
|
[27] = ColorUtil.PURPLE_DARK,
|
|
}
|
|
-- 采集物nameboard颜色
|
|
GuildModel.CSGRCollectionNameColor = {
|
|
[653101] = ColorUtil.PURPLE_DARK,
|
|
[653102] = ColorUtil.PURPLE_DARK,
|
|
[653103] = ColorUtil.PURPLE_DARK,
|
|
[653104] = ColorUtil.PURPLE_DARK,
|
|
}
|
|
-- 本国团战侧边栏下方阶段描述
|
|
GuildModel.CSGRStageDesc = {
|
|
[1] = "采集物资可给社团所有成员增加对应效果，采集的越多效果越强",
|
|
[2] = "采集物资可给社团所有成员增加对应效果，采集的越多效果越强",
|
|
}
|
|
--封印裂隙奖励预览界面奖励 1|封印裂隙奖励 2|封印魔王触发者奖励 3|封印魔王协助者奖励
|
|
GuildModel.GuildCollectRewardList = {
|
|
[1] = {{100,251008,1},{100,251007,3}},
|
|
[2] = {{100,251008,1},{100,251007,3}},
|
|
[3] = {{100,251008,1},{100,251007,3}},
|
|
}
|
|
|
|
-- 协助感谢类型
|
|
GuildModel.SupportThankType = {
|
|
Normal = 1, -- 通用感谢
|
|
SpellList = 2, -- 拼单感谢
|
|
}
|
|
local GuildModel = GuildModel
|
|
local Config_Guildbadge = Config.Guildbadge
|
|
|
|
function GuildModel:__init()
|
|
GuildModel.Instance = self
|
|
self:ClearData()
|
|
end
|
|
|
|
function GuildModel:getInstance()
|
|
if GuildModel.Instance == nil then
|
|
GuildModel.New();
|
|
end
|
|
return GuildModel.Instance;
|
|
end
|
|
|
|
--清除缓存数据
|
|
function GuildModel:ClearData()
|
|
self.guild_list = {}
|
|
self.base_info = {} -- 社团基础信息
|
|
self.member_list = {}
|
|
self.goods_list = {}
|
|
self.role_permission_list = {} --玩家权限列表
|
|
self.position_num_list = {} -- 当前职位人数
|
|
self.invite_enter_list = {} --邀请入会列表
|
|
self.guild_funds = 0 -- 社团资金
|
|
self.guid_announce = ""
|
|
self.apply_member_list = {}
|
|
self.apply_guild_list = {} -- 申请加入社团玩家列表
|
|
self.apply_pos_list = {} -- 职位申请列表
|
|
self.last_recruit_time = -30 -- 上次发布社团招募信息的时间
|
|
self.last_send_chuanwen_time = -10 -- 上次发布社团传闻的时间
|
|
self.guild_announce_times_data = nil -- 社团公告修改次数信息
|
|
self.guild_kv_cfg = nil
|
|
self.guild_collect_kv_cfg = nil -- 社团采集活动常量配置
|
|
self._need_auto_botting = false -- 切换到社团场景后是否需要自动挂机
|
|
self.guild_event_act_tip_cache = {} -- 社团活动类型提示缓存
|
|
self.history_guild_num = 999 -- 历史最大社团创建数，前五时可享受创建折扣
|
|
self.handle_40071_flag = false --控制40071查询社团数量的标志 1时处理列表界面 2时处理创建界面
|
|
|
|
--社团拍卖提示
|
|
self.guild_auction_hide = true
|
|
self.guild_auction_time = 0
|
|
self.guild_auction_cfg = false
|
|
-------------------
|
|
-- 自动审批的相关内容
|
|
self.approve_type = 0 -- 审批设置0:条件自动加1:手动批准入
|
|
self.auto_approve_lv = 0 --最低等级
|
|
self.auto_approve_power = 0 --最低战力
|
|
-- 社团活跃内容
|
|
self.personal_active = 0 -- 社团个人活跃
|
|
self.personal_stage = 0 -- 社团活跃奖励领取阶段
|
|
self.active_task = {} -- 社团任务进度信息
|
|
self.guild_active = 0 -- 社团总活跃度
|
|
self.guild_active_stage = 0 -- 社团活跃奖励领取阶段
|
|
self.guild_week_stime = 0 -- 本周的活跃开始时间(计算结束时间需要加上7*86400)
|
|
self.guild_log_list = {} -- 社团日志列表
|
|
self.guild_merge_info = nil -- 社团合并信息
|
|
self.guild_merge_apply_cache = {} -- 收到其他社团合并请求的社团id缓存
|
|
--- 社团拼单 ---
|
|
self.guild_sl_data = {} -- 社团拼单信息
|
|
self.guild_cur_sl_orderId = nil -- 当前选中的拼单订单id
|
|
self.guild_cur_sl_order_data = nil -- 当前选中的拼单
|
|
self.guild_sl_invite_time = {} -- 拼单邀请社团成员时间戳
|
|
self.cur_guild_spelllist_thankId = nil -- 当前可以自动感谢的拼单协助id 40048
|
|
self._dont_check_sl_refresh = false -- 是否检查社团拼单刷新
|
|
self._dont_check_sl_invited = false -- 是否检查社团拼单邀请刷新提示
|
|
self._dont_check_sl_high_quality = false -- 是否询问高品质拼单的刷新
|
|
self._is_in_guild_spelllist_view = false -- 是否在社团拼单界面
|
|
--- 社团活动 ---
|
|
self.guild_act_list = nil -- 当日所有活动列表（玩家升级||前端跨天 会清除缓存）
|
|
--- 红点相关 ---
|
|
self.guild_red_cache = {} -- 社团红点缓存
|
|
self.merge_tip_red = false -- 低活跃社团合并提示红点
|
|
self.save_merge_cache_time = false -- 是否立即更新合并时间的缓存
|
|
self.member_refresh_check = true -- 社团主界面人员管理红点首次检查标志
|
|
self.member_apply_red = false -- 社团人员管理申请页签红点
|
|
self.pos_apply_red = false -- 社团人员管理申请页签红点
|
|
self.member_merge_red = false -- 社团人员管理合并按钮红点
|
|
self.guild_order_login_red = true -- 社团拼单登录红点
|
|
self.guild_event_tab_red = {} -- 社团活动红点列表
|
|
self.guild_shop_special_item_red = {} -- 社团特殊商品红点缓存
|
|
self.show_guild_shop_red = true -- 展示社团商店红点(需要满足特定条件)
|
|
self.g_boss_roll_red_num = 0 -- 社团bossroll点红点数量
|
|
-- 社团活动管理
|
|
self.guild_evt_data = {} -- 社团活动数据列表，包括活动开启情况和时间
|
|
--- 社团采集 ---
|
|
self.is_collect_active = false -- 当前采集封印活动是否开启
|
|
self.collect_end_time = 0 -- 本次封印活动的结束时间戳
|
|
self.now_collect_seal_times = 0 -- 本次封印活动的采集次数
|
|
self.collect_left_time = 0 -- 本次封印活动还剩下的时间
|
|
self.guild_collect_ignore_list = {} -- 忽略搜索的采集物id
|
|
self.day_total_collect_times = 0 --当日一共采集的次数，当天最大不超过30次
|
|
self.now_left_collect_mon_count = 0 --场景当前剩余的采集怪数量
|
|
self.guild_collect_helper_info = {}--封印裂隙协助者助战信息
|
|
self.auto_guild_collect_state = 0--自动采集状态 与自动挂机状态互斥 0|关闭 1|开启
|
|
self.now_guild_collect_support_id = 0--当前的封印裂隙唯一协助id
|
|
self.last_chat_collect_support_time = 0--上次在聊天频道喊话的时间戳
|
|
--- 社团boss ---
|
|
self.guild_boss_hp_data = nil -- 社团boss血量信息 40601
|
|
self.guild_boss_rank = {} -- 社团boss社团输出排行
|
|
self.guild_boss_personal_rank = {} -- 社团boss个人排行信息
|
|
self.guild_boss_invincible = nil -- 社团boss狂暴信息
|
|
self.guild_boss_hp_sim = 0 --用于血条显示的模拟血量
|
|
self.encourage_free_times = 0 --免费鼓舞已经使用的次数
|
|
self.encourage_cost_times = 0 --付费鼓舞已经使用的次数
|
|
self.encourage_guild_times = 0 --鼓舞社团加成次数
|
|
self.gboss_col_drop_id = 0 -- 当前社团boss掉落采集道具掉落id
|
|
self.guild_boss_roll_start_time = 0 -- 本轮社团bossroll点的开始时间
|
|
self.guild_boss_roll_data_raw = {} -- 社团bossroll点道具数据（自然键值列表）
|
|
self.guild_boss_roll_data = {} -- 社团bossroll点道具数据
|
|
self.guild_boss_roll_record = {} -- 社团bossroll点记录
|
|
self.guild_boss_roll_finished = false -- 社团bossroll点本轮是否已经结束
|
|
self.guild_boss_role_highest_roleId = {} -- 社团bossroll点最高分数玩家id缓存
|
|
self._gboss_need_show_claim_red = false -- 社团bossroll点界面不存在时是否需要提示roll点按钮红点
|
|
-- self.gboss_roll_result = {} -- 社团bossroll点结算信息缓存
|
|
-- self.gboss_roll_result_cdtimer_id = nil
|
|
-- self.is_in_gboss_result_cd = false
|
|
--社团协助相关---
|
|
self.guild_support_info = {} -- 社团协助信息列表
|
|
self.guild_support_award_info = {}--社团协助奖励信息列表
|
|
self.guild_support_cfg = {} --社团协助配置信息
|
|
self.guild_support_thank_cfg_id = nil--当前感谢的礼包唯一ID
|
|
self.guild_daliy_reputation = nil--每日获得的名望券数量
|
|
self.self_support_sid = 0--自己的社团协助ID
|
|
self.support_thank_list = {}--协助感谢列表
|
|
self.support_gift_list = {}--协助感谢领取列表
|
|
self.support_red_list = {}--协助感谢领取列表
|
|
self.cur_choose_thank_data = nil
|
|
self.is_start_open_support_continue = nil
|
|
self.support_is_self_send = false--协助是否是自己发送的
|
|
self:InitGuildSupportCfg()
|
|
-- 社团派对相关 --
|
|
self.guild_party_exp_radio_cfg = nil
|
|
self.guild_party_exp = 0 -- 社团派对累计经验值
|
|
self.guild_party_exp_eff = 0 -- 社团派对每分钟的预测奖励经验值
|
|
self.self_support_status = 0 -- 协助状态
|
|
self.guild_scene_mem_num = 0 -- 驻地内玩家人数
|
|
self.guild_party_radio = 0 -- 驻地内玩家人数经验效率（万分比）
|
|
--本服团战相关
|
|
self.guild_war_info = {} --本服团战数据
|
|
-- 本国团战相关
|
|
self.csgr_kv_config = nil -- 本国团战常量配置
|
|
self.csgr_guild_reward_cfg = nil -- 本国团战社团奖励配置
|
|
self.csgr_guild_reward_cfg_normal = nil -- 本国团战社团奖励配置(其他战场)
|
|
self.csgr_role_reward_cfg = nil -- 本国团战玩家奖励配置
|
|
self.csgr_fight_info = nil -- 本轮本国团战同战场公会信息
|
|
self.csgr_collect_buff = {} -- 本轮本国团战社团已经采集到的buff信息
|
|
self.csgr_bf_res = {} -- 本轮本国团战战场内物资信息
|
|
self.csgr_bf_res_refreshtime = 0 -- 战场物资刷新时间戳
|
|
self.guild_csgr_result_data = nil -- 本国团战结算信息
|
|
self.csgr_result_data = nil -- 本国团战结算协议信息
|
|
self.csgr_scene_last_pos = Vector2(0, 0) -- 本国团战上一帧的坐标
|
|
self.csgr_collect_cfg_data = nil -- 本国团战采集怪坐标（顺序表）
|
|
self.csgr_collect_cfg_data2 = nil -- 本国团战采集怪坐标（attr_id键值表）
|
|
self.csgr_auto_collect = false -- 本国团战自动采集标志量
|
|
self.need_show_sos = false--默认展示SOS协助图标
|
|
|
|
|
|
self.war_active_show_red_dot = {} --战场活动提示红点缓存
|
|
end
|
|
|
|
function GuildModel:ClearActList( )
|
|
self.guild_act_list = nil
|
|
end
|
|
|
|
-- 配置相关 start
|
|
-- 获取社团常量配置内容
|
|
function GuildModel:GetGuildKvByKey(key)
|
|
if not self.guild_kv_cfg then
|
|
self.guild_kv_cfg = {}
|
|
local temp_key
|
|
for k, v in pairs(Config.Guildkv) do
|
|
temp_key = Trim(v.key)
|
|
self.guild_kv_cfg[temp_key] = v
|
|
end
|
|
end
|
|
return self.guild_kv_cfg[key]
|
|
end
|
|
|
|
-- 获取社团采集活动常量配置内容
|
|
function GuildModel:GetGuildCollectKvByKey(key)
|
|
if not self.guild_collect_kv_cfg then
|
|
self.guild_collect_kv_cfg = {}
|
|
local temp_key
|
|
for k, v in pairs(Config.Guildcollectkv) do
|
|
temp_key = Trim(v.key)
|
|
self.guild_collect_kv_cfg[temp_key] = v
|
|
end
|
|
end
|
|
return self.guild_collect_kv_cfg[key]
|
|
end
|
|
|
|
-- 获取社团徽章加成信息
|
|
-- type:徽章类型，存在该字段时返回当前社团存在的最高加成的属性值，否则直接返回协议返回的徽章列表
|
|
function GuildModel:GetGuildBadgeInfo(type)
|
|
local badge_list = self.base_info and self.base_info.badges or {}
|
|
if type then
|
|
local cfg
|
|
for k, v in ipairs(badge_list) do
|
|
cfg = Config_Guildbadge[v.id]
|
|
-- 存在目标类型的配置时，返回配置的加成值，具体值单位还要参考配置
|
|
if cfg and cfg.type == type then
|
|
return cfg.effect
|
|
end
|
|
end
|
|
return 0
|
|
else
|
|
return badge_list
|
|
end
|
|
end
|
|
|
|
-- 根据开服天数获取合并社团限制配置
|
|
function GuildModel:GetGuildMergeConditionCfg( )
|
|
local open_day = ServerTimeModel:getInstance():GetOpenServerDay()
|
|
local merge_condition = nil
|
|
for k, v in pairs(Config.Guildmerge) do
|
|
if v.min_day <= open_day and v.max_day >= open_day then
|
|
merge_condition = v
|
|
break
|
|
end
|
|
end
|
|
return merge_condition
|
|
end
|
|
|
|
--保存历史社团最大创建数
|
|
function GuildModel:SetHistoryGuildNum(vo)
|
|
self.history_guild_num = vo.history_guild_num
|
|
end
|
|
|
|
--当前是否创建社团折扣期
|
|
function GuildModel:IsInCreateGuildDiscount( )
|
|
local total_num = stringtotable(self:GetGuildKvByKey("create_guild_discount").val)[1]
|
|
return self.history_guild_num < total_num
|
|
end
|
|
|
|
-- 获取社团商城物品配置
|
|
function GuildModel:GetGuildShopGoodsCfg( )
|
|
self.guild_shop_cfg = self.guild_shop_cfg or {}
|
|
if IsTableEmpty(self.guild_shop_cfg) then
|
|
local lv = RoleManager.Instance.mainRoleInfo.level
|
|
local guild_lv = self.base_info.guild_lv or 0
|
|
for k, v in pairs(Config.Guildcargo) do
|
|
if v.lv_min <= lv and v.lv_max >= lv then -- 只显示符合等级区间的商品
|
|
v.lock_guild = guild_lv < v.guild_lv
|
|
end
|
|
self.guild_shop_cfg[#self.guild_shop_cfg+1] = v
|
|
end
|
|
end
|
|
return self.guild_shop_cfg
|
|
end
|
|
-- 清空社团商店缓存
|
|
function GuildModel:ClearGuildShopCfgCache( )
|
|
self.guild_shop_cfg = nil
|
|
end
|
|
|
|
-- 获取社团活跃任务状态
|
|
function GuildModel:GetGuildActiveTaskCfg( )
|
|
--今天是星期几
|
|
local cur_weekday = tonumber(os.date("%w", TimeUtil:getServerTime()))
|
|
cur_weekday = cur_weekday ~= 0 and cur_weekday or 7
|
|
local tb = {}
|
|
local task_data = nil
|
|
local sort_weight = { -- 根据领取状态获得排序权重
|
|
[0] = 1, -- 未完成
|
|
[1] = 2, -- 可领取
|
|
[2] = 0, -- 已完成
|
|
}
|
|
for k, v in pairs(Config.Guildtask) do
|
|
local day_condition = stringtotable(v.days)
|
|
if IsTableEmpty(day_condition) then
|
|
task_data = self:GetGuildActiveTaskData(v.id)
|
|
local state = task_data and task_data.state or 0
|
|
v.sort_weight = sort_weight[state]
|
|
tb[#tb+1] = v
|
|
else
|
|
for k2, v2 in pairs(day_condition) do
|
|
if v2 == cur_weekday then
|
|
task_data = self:GetGuildActiveTaskData(v.id)
|
|
local state = task_data and task_data.state or 0
|
|
v.sort_weight = sort_weight[state]
|
|
tb[#tb+1] = v
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- 根据领取状态排序
|
|
local sort_func = function ( a, b )
|
|
if a.sort_weight == b.sort_weight then
|
|
return a.id < b.id
|
|
else
|
|
return a.sort_weight > b.sort_weight
|
|
end
|
|
end
|
|
table.sort(tb, sort_func)
|
|
return tb
|
|
end
|
|
|
|
-- 获取社团活跃配置
|
|
function GuildModel:GetActiveRewardCfg( )
|
|
local tb = {}
|
|
local target_cfg = Config.Guildtaskguildaward
|
|
local guild_lv = self.base_info.guild_lv or 1
|
|
local open_day = ServerTimeModel:getInstance():GetOpenServerDay()
|
|
|
|
for k, v in pairs(target_cfg) do
|
|
if guild_lv >= v.glv_min and guild_lv <= v.glv_max -- 社团等级满足需求
|
|
and open_day >= v.day_min and open_day <= v.day_max then -- 开服天数满足需求
|
|
tb[#tb+1] = v
|
|
end
|
|
end
|
|
local sort_func = function ( a, b )
|
|
return a.id < b.id
|
|
end
|
|
table.sort(tb, sort_func)
|
|
return tb
|
|
end
|
|
|
|
-- 根据星期数获取当天社团活动
|
|
function GuildModel:GetGuildEventByWday(wday)
|
|
-- if not wday then return nil end
|
|
-- 获取今天全部限时活动数据
|
|
if not self.guild_act_list then
|
|
local all_act = Config.Ac
|
|
local key
|
|
local role_lv = RoleManager.Instance.mainRoleInfo.level
|
|
self.guild_act_list = {}
|
|
local act_list = DailyModel:getInstance():GetWeekCalendarInfo(true) -- 获取限时活动的日历
|
|
-- 处理限时活动的部分
|
|
for k, wday_evt in ipairs(act_list) do
|
|
for k2, evt in ipairs(wday_evt) do
|
|
if type(evt) == "table" then
|
|
key = evt.module_id .. "@" .. evt.module_sub
|
|
if GuildModel.EventModuleId[key]
|
|
and Config.Moduleid[evt.module_id]
|
|
and Config.Moduleid[evt.module_id].open_lv <= role_lv then -- 2020年3月18日新增活动对等级的要求判断
|
|
evt.time_str = wday_evt[1] -- 第一条内容是活动时间
|
|
self.guild_act_list[k2 - 1] = self.guild_act_list[k2 - 1] or {}
|
|
self:CheckRepeatEvt(self.guild_act_list[k2 - 1], evt)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if wday then
|
|
return self.guild_act_list[wday] or {}
|
|
else
|
|
return self.guild_act_list
|
|
end
|
|
end
|
|
-- 检查同一活动多个时间段开启的情况，这个时候只保留第一个
|
|
function GuildModel:CheckRepeatEvt(list, evt )
|
|
-- 判断该社团活动是不是不可以同时在活动界面中存在多个的活动
|
|
if not GuildModel.AllowRepeatEvent[evt.module_id] then
|
|
for k, v in pairs(list) do
|
|
if v.module_id == evt.module_id and v.module_sub == evt.module_sub then
|
|
return
|
|
end
|
|
end
|
|
end
|
|
table.insert(list, evt)
|
|
end
|
|
|
|
-- 获取目标社团活动的开启时间，格式为周x、x、x 开始时间
|
|
-- time_only 只需要活动的时间
|
|
function GuildModel:GetGuildEventOpenTime(module_id, module_sub, ac_sub, time_only)
|
|
if not module_id or not module_sub then return "" end
|
|
ac_sub = ac_sub or 1
|
|
local all_list = self:GetGuildEventByWday()
|
|
local str, day_num, start_time, end_time = "", 0, "", ""
|
|
-- 这里有可能存在开服的前几天没有活动的情况，所以要用pairs
|
|
for k, wday_evt in pairs(all_list) do -- 7天的总活动列表
|
|
for k2, evt in ipairs(wday_evt) do -- 每天的活动列表
|
|
if evt.module_id == module_id and evt.module_sub == module_sub and evt.ac_sub == ac_sub then
|
|
day_num = day_num + 1
|
|
str = str .. (day_num <= 1 and "周" or "、") .. TimeUtil:GetWeekStrNum(k)
|
|
if start_time == "" then
|
|
start_time = Split(evt.time_str, "~")[1]
|
|
end_time = Split(evt.time_str, "~")[2]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if time_only then
|
|
local start_time_tb = Split(start_time, ":")
|
|
local s_hour, s_min = tonumber(start_time_tb[1]), start_time_tb[2] == "00" and 0 or tonumber(start_time_tb[2])
|
|
local end_time_tb = Split(end_time, ":")
|
|
local e_hour, e_min = tonumber(end_time_tb[1]), end_time_tb[2] == "00" and 0 or tonumber(end_time_tb[2])
|
|
return s_hour, s_min, e_hour, e_min
|
|
else
|
|
if day_num >= TableSize(all_list) then
|
|
str = "每日"
|
|
end
|
|
return str .. " <color=#2CF86F>" .. start_time .."-"..end_time.."</color>，限时开启", str
|
|
end
|
|
end
|
|
|
|
--获取封印裂隙的开启时间(时间列表中没有区分活动场次的字段，只能特殊处理)
|
|
function GuildModel:GetGuildEventCollectOpenTime(index,time_only)--index:场次
|
|
local module_id = 408
|
|
local module_sub = 0
|
|
local all_list = self:GetGuildEventByWday()
|
|
local str, day_num, start_time, end_time = "", 0, "", ""
|
|
-- 这里有可能存在开服的前几天没有活动的情况，所以要用pairs
|
|
local collect_list = {}
|
|
for k, wday_evt in pairs(all_list) do -- 7天的总活动列表
|
|
for k2, evt in ipairs(wday_evt) do -- 每天的活动列表
|
|
if evt.module_id == module_id and evt.module_sub == module_sub then
|
|
day_num = day_num + 1
|
|
str = str .. (day_num <= 1 and "周" or "、") .. TimeUtil:GetWeekStrNum(k)
|
|
table.insert(collect_list,evt)
|
|
end
|
|
end
|
|
end
|
|
if start_time == "" and collect_list[index] then
|
|
start_time = Split(collect_list[index].time_str, "~")[1]
|
|
end_time = Split(collect_list[index].time_str, "~")[2]
|
|
end
|
|
if time_only then
|
|
local start_time_tb = Split(start_time, ":")
|
|
local s_hour, s_min = tonumber(start_time_tb[1]), start_time_tb[2] == "00" and 0 or tonumber(start_time_tb[2])
|
|
local end_time_tb = Split(end_time, ":")
|
|
local e_hour, e_min = tonumber(end_time_tb[1]), end_time_tb[2] == "00" and 0 or tonumber(end_time_tb[2])
|
|
return s_hour, s_min, e_hour, e_min
|
|
else
|
|
if day_num >= TableSize(all_list) then
|
|
str = "每日"
|
|
end
|
|
return str .. " <color=#2CF86F>" .. start_time .."-"..end_time.."</color>，限时开启"
|
|
end
|
|
end
|
|
|
|
--找某个活动的持续时间总长
|
|
function GuildModel:GetGuildEventStayTime(module_id, module_sub, ac_sub)
|
|
ac_sub = ac_sub or 1
|
|
local s_hour, s_min, e_hour, e_min = self:GetGuildEventOpenTime(module_id,module_sub,ac_sub,true)
|
|
local stay_time = 0
|
|
if e_hour > s_hour then
|
|
stay_time = e_min + 60*(e_hour-s_hour) - s_min
|
|
else
|
|
stay_time = e_min - s_min
|
|
end
|
|
return stay_time * 60
|
|
end
|
|
|
|
--获取社团boss常量表
|
|
function GuildModel:GetGuildBossKV(key)
|
|
return Config.Guildbosskv[key].value
|
|
end
|
|
|
|
--初始化协助配置
|
|
function GuildModel:InitGuildSupportCfg( )
|
|
self.guild_support_cfg = {}
|
|
local cfg_data = DeepCopy(Config.Guildsupport)
|
|
for k,v in pairs(cfg_data) do
|
|
local data = v
|
|
data.mod_name = Trim(data.mod_name)
|
|
data.thank_reward = stringtotable(v.thank_reward)--进入条件
|
|
data.support_reward = stringtotable(v.support_reward)--协助奖励
|
|
self.guild_support_cfg[v.support_id] = data
|
|
end
|
|
end
|
|
--得到协助配置
|
|
function GuildModel:GetGuildSupportCfg( support_id )
|
|
return self.guild_support_cfg[support_id]
|
|
end
|
|
--得到协助配置
|
|
function GuildModel:OpenGuildSupportThankView( )
|
|
local function func()
|
|
if #self.guild_support_award_info == 0 then
|
|
if self.support_time_id then
|
|
GlobalTimerQuest:CancelQuest(self.support_time_id)
|
|
self.support_time_id = nil
|
|
end
|
|
end
|
|
if #self.guild_support_award_info > 0 and GuildController.Instance
|
|
and (GuildController.Instance.GuildSupportThankView and not GuildController.Instance.GuildSupportThankView:HasOpen()
|
|
or not GuildController.Instance.GuildSupportThankView)
|
|
then
|
|
if self.support_time_id then
|
|
GlobalTimerQuest:CancelQuest(self.support_time_id)
|
|
self.support_time_id = nil
|
|
end
|
|
GuildModel:getInstance():Fire(GuildModel.OPEN_GUILD_SUPPORT_THANK_VIEW,GuildModel.SupportType.Award)
|
|
end
|
|
end
|
|
if not self.support_time_id then
|
|
self.support_time_id = GlobalTimerQuest:AddPeriodQuest(func,0.5)
|
|
end
|
|
end
|
|
--获得玩法名望券
|
|
function GuildModel:GetPlayReputation( module_id,module_sub )
|
|
for k,v in pairs(self.guild_support_cfg) do
|
|
if v.module_id == module_id and v.sub_mod_id == module_sub then
|
|
return v.reward_reputation
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 获取本国团战的常量配置
|
|
function GuildModel:GetCSGRConfigByKey(key)
|
|
if not self.csgr_kv_config then
|
|
self.csgr_kv_config = {}
|
|
local temp_key
|
|
for k, v in pairs(Config.Campwarkv) do
|
|
temp_key = Trim(v.key)
|
|
self.csgr_kv_config[temp_key] = v
|
|
end
|
|
end
|
|
return self.csgr_kv_config[key]
|
|
end
|
|
|
|
function GuildModel:GetCSGRRankRewardCfg( )
|
|
local sort_func = function ( a, b )
|
|
return a.rank_min < b.rank_min
|
|
end
|
|
if not self.csgr_role_reward_cfg then
|
|
self.csgr_role_reward_cfg = {}
|
|
local temp_tb
|
|
for k, v in pairs(Config.Campwarrolerankreward) do
|
|
temp_tb = DeepCopy(v)
|
|
temp_tb.rewards = stringtotable(v.rewards)
|
|
self.csgr_role_reward_cfg[#self.csgr_role_reward_cfg+1] = temp_tb
|
|
end
|
|
table.sort(self.csgr_role_reward_cfg, sort_func)
|
|
end
|
|
if not self.csgr_guild_reward_cfg or not self.csgr_guild_reward_cfg_normal then
|
|
self.csgr_guild_reward_cfg = {}
|
|
self.csgr_guild_reward_cfg_normal = {}
|
|
local temp_tb
|
|
for k, v in pairs(Config.Campwarrankreward) do
|
|
temp_tb = DeepCopy(v)
|
|
temp_tb.rewards = stringtotable(v.rewards)
|
|
if v.arena_id == 1 then -- 1号战场
|
|
self.csgr_guild_reward_cfg[#self.csgr_guild_reward_cfg+1] = temp_tb
|
|
else
|
|
self.csgr_guild_reward_cfg_normal[#self.csgr_guild_reward_cfg_normal+1] = temp_tb
|
|
end
|
|
end
|
|
table.sort(self.csgr_guild_reward_cfg, sort_func)
|
|
table.sort(self.csgr_guild_reward_cfg_normal, sort_func)
|
|
end
|
|
return self.csgr_guild_reward_cfg, self.csgr_guild_reward_cfg_normal, self.csgr_role_reward_cfg
|
|
end
|
|
|
|
-- 初始化社团派对挂机效率万分比配置
|
|
function GuildModel:GetGuildPartyEffRadioCfg( )
|
|
if not self.guild_party_exp_radio_cfg then
|
|
self.guild_party_exp_radio_cfg = {}
|
|
for k, v in pairs(Config.Guildtriberadio) do
|
|
self.guild_party_exp_radio_cfg[#self.guild_party_exp_radio_cfg+1] = v
|
|
end
|
|
local sort_func = function ( a, b )
|
|
return a.num_min < b.num_min
|
|
end
|
|
table.sort(self.guild_party_exp_radio_cfg, sort_func)
|
|
end
|
|
return self.guild_party_exp_radio_cfg
|
|
end
|
|
-- 配置相关 end
|
|
|
|
--------- 社团协议相关代码 start ---------
|
|
-- 设置社团的基本信息 40005
|
|
function GuildModel:SetGuildBaseInfo(vo)
|
|
self.base_info = vo
|
|
self:SortGuildBadge(vo.badges)
|
|
end
|
|
function GuildModel:GetGuildBaseInfo( )
|
|
return self.base_info
|
|
end
|
|
-- 排序社团徽章的顺序
|
|
function GuildModel:SortGuildBadge(badge_list)
|
|
if badge_list then
|
|
-- 补齐没有勋章的情况
|
|
local has_badge1, has_badge2, has_badge3
|
|
local temp_cfg = nil
|
|
for k, v in pairs(badge_list) do
|
|
temp_cfg = Config_Guildbadge[v.id]
|
|
if temp_cfg.type == 1 then
|
|
has_badge1 = true
|
|
elseif temp_cfg.type == 6 then
|
|
has_badge2 = true
|
|
elseif temp_cfg.type == 2 then
|
|
has_badge3 = true
|
|
end
|
|
end
|
|
if not has_badge1 then
|
|
badge_list[#badge_list + 1] = {id = 1001, start_time = 0, end_time = 0}
|
|
end
|
|
if not has_badge2 then
|
|
badge_list[#badge_list + 1] = {id = 2001, start_time = 0, end_time = 0}
|
|
end
|
|
if not has_badge3 then
|
|
badge_list[#badge_list + 1] = {id = 3001, start_time = 0, end_time = 0}
|
|
end
|
|
-- 排序
|
|
local sort_func = function ( a, b )
|
|
return a.id < b.id
|
|
end
|
|
table.sort(badge_list, sort_func)
|
|
end
|
|
end
|
|
-- 获取社团的成员列表 40006
|
|
function GuildModel:SetGuildMemberList(vo)
|
|
self.member_list = vo
|
|
end
|
|
function GuildModel:GetGuildMemberList( )
|
|
return self.member_list
|
|
end
|
|
|
|
-- 设置社团的申请列表 40008
|
|
function GuildModel:SetApplyMemberListData(vo)
|
|
local sort_func = function ( a, b )
|
|
return a.time < b.time
|
|
end
|
|
table.sort(vo, sort_func)
|
|
self.apply_member_list = vo
|
|
self:SetApplyDataSpiltJoinAndPos(vo)
|
|
end
|
|
function GuildModel:GetApplyMemberListData( )
|
|
return self.apply_member_list
|
|
end
|
|
-- 筛选区分加入社团和职位申请的申请信息
|
|
function GuildModel:SetApplyDataSpiltJoinAndPos(vo)
|
|
if not vo then return end
|
|
self.apply_guild_list = {}
|
|
self.apply_pos_list = {}
|
|
for k, v in ipairs(vo) do
|
|
if v.position == 0 then
|
|
self.apply_guild_list[#self.apply_guild_list+1] = v
|
|
else
|
|
self.apply_pos_list[#self.apply_pos_list+1] = v
|
|
end
|
|
end
|
|
end
|
|
function GuildModel:GetApplyGuildMemData( )
|
|
return self.apply_guild_list
|
|
end
|
|
function GuildModel:GetApplyPosMemData( )
|
|
return self.apply_pos_list
|
|
end
|
|
|
|
-- 更新申请列表 40009 40014
|
|
function GuildModel:UpdateApplyMemberList(vo)
|
|
for k, v in pairs(self.apply_member_list) do
|
|
if v.role_id == vo.role_id then
|
|
table.remove(self.apply_member_list, k)
|
|
break
|
|
end
|
|
end
|
|
for k, v in pairs(self.apply_guild_list) do
|
|
if v.role_id == vo.role_id then
|
|
table.remove(self.apply_guild_list, k)
|
|
break
|
|
end
|
|
end
|
|
for k, v in pairs(self.apply_pos_list) do
|
|
if v.role_id == vo.role_id then
|
|
table.remove(self.apply_pos_list, k)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 设置社团自动加入相关内容 40010
|
|
function GuildModel:SetAutoApproveData(vo)
|
|
self.approve_type = vo.approve_type
|
|
self.auto_approve_lv = vo.auto_approve_lv
|
|
self.auto_approve_power = vo.auto_approve_power
|
|
end
|
|
|
|
-- 设置社团公告 40012
|
|
function GuildModel:SetGuildAnnounce(guid_announce)
|
|
self.guid_announce = Trim(guid_announce)
|
|
end
|
|
function GuildModel:UpdateGuildBasicInfoAnnounce(guid_announce)
|
|
if self.base_info then
|
|
self.base_info.announce = guid_announce
|
|
end
|
|
end
|
|
function GuildModel:GetGuildAnnounce( )
|
|
return self.guid_announce
|
|
end
|
|
|
|
-- 更新社团玩家职位信息 40013
|
|
function GuildModel:UpdateMemberPositionData( vo )
|
|
for k, v in pairs(self.member_list) do
|
|
if v.role_id == vo.role_id then
|
|
v.position = vo.position
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 更新玩家所在的社团信息 40015
|
|
function GuildModel:UpdateGuildBaseInfo(vo)
|
|
self.base_info.guild_id = vo.guild_id
|
|
self.base_info.guild_name = vo.guild_name
|
|
-- self.base_info.guild_lv = vo.guild_lv
|
|
end
|
|
|
|
-- 设置社团公告修改次数信息 40019
|
|
function GuildModel:SetGuildAnnounceTimesData(vo)
|
|
self.guild_announce_times_data = self.guild_announce_times_data or {}
|
|
self.guild_announce_times_data.remain_times = vo.remain_times
|
|
self.guild_announce_times_data.free_times = vo.free_times
|
|
end
|
|
function GuildModel:GetGuildAnnounceTimesData( )
|
|
return self.guild_announce_times_data
|
|
end
|
|
|
|
--设置玩家的权限 40021
|
|
function GuildModel:SetRolePermission(vo)
|
|
self.role_permission_list = {}
|
|
local len = #vo.permission_type_list
|
|
local permission
|
|
for i = 1,len do
|
|
permission = vo.permission_type_list[i]["permission_type"]
|
|
if permission then
|
|
table.insert(self.role_permission_list,permission)
|
|
end
|
|
end
|
|
self:Fire(GuildModel.RefreshPermissionListEvt)
|
|
end
|
|
--检测玩家是否有当前权限
|
|
function GuildModel:HasOperatePermission(permission)
|
|
local len = #self.role_permission_list
|
|
local vo
|
|
for i = 1,len do
|
|
vo = self.role_permission_list[i]
|
|
if tonumber(vo) == tonumber(permission) then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
-- 检测玩家是否对目标职位由任命权限
|
|
function GuildModel:HasAppointPremission(target_pos, cur_pos)
|
|
cur_pos = cur_pos or RoleManager.Instance.mainRoleInfo.position
|
|
if cur_pos > GuildModel.GuildPosition.ViceLeader then return false end
|
|
if cur_pos == GuildModel.GuildPosition.ViceLeader then return cur_pos < target_pos end
|
|
if cur_pos == GuildModel.GuildPosition.Leader then return true end
|
|
end
|
|
|
|
--设置当前职位人数 40023
|
|
function GuildModel:SetCurrentPostNumInfo(vo)
|
|
self.position_num_list = vo.position_num_list
|
|
end
|
|
|
|
-- 修改社团名称和社团旗帜 40025
|
|
function GuildModel:UpdateGuildNameAndFlag(vo)
|
|
if self.base_info then
|
|
self.base_info.guild_name = vo.guild_name
|
|
self.base_info.guild_flag = vo.guild_flag
|
|
end
|
|
end
|
|
function GuildModel:GetGuildFlag( )
|
|
local flag = 0
|
|
if self.base_info then
|
|
flag = self.base_info.guild_flag or 0
|
|
end
|
|
return flag
|
|
end
|
|
|
|
--获取当前职位人数
|
|
function GuildModel:GetMemberNum(position)
|
|
local num = 0
|
|
for k, v in pairs(self.member_list) do
|
|
if v.position == position then
|
|
num = num + 1
|
|
end
|
|
end
|
|
return num
|
|
-- local len = #self.position_num_list
|
|
-- local vo
|
|
-- for i = 1,len do
|
|
-- vo = self.position_num_list[i]
|
|
-- if vo.position == position then
|
|
-- return vo.num
|
|
-- end
|
|
-- end
|
|
-- return 0
|
|
end
|
|
|
|
-- 设置商城商品信息 40027
|
|
function GuildModel:SetGuildShopGoodsList(goods_list)
|
|
self.goods_list = {}
|
|
local shop_cfg = self:GetGuildShopGoodsCfg()
|
|
local temp_goods_list = {}
|
|
for k, v in pairs(goods_list) do
|
|
temp_goods_list[v.id] = v
|
|
end
|
|
for k, cfg in ipairs(shop_cfg) do
|
|
-- 获取该商品的购买记录
|
|
local buy_record = temp_goods_list[cfg.id]
|
|
cfg.buy_num = buy_record and buy_record.buyed or 0
|
|
cfg.can_buy = cfg.type == GuildModel.ShopBuyType.NoLimit or cfg.buy_num < cfg.num
|
|
self.goods_list[k] = cfg
|
|
end
|
|
self:SortGuildShopData()
|
|
end
|
|
function GuildModel:SortGuildShopData( )
|
|
local sort_func = function ( a, b )
|
|
if a.lock_guild ~= b.lock_guild then -- 被锁定的在后
|
|
return not a.lock_guild
|
|
elseif a.can_buy ~= b.can_buy then -- 可购买的在前
|
|
return a.can_buy
|
|
else
|
|
if a.type ~= b.type then -- 购买类型大的在前
|
|
return a.type > b.type
|
|
else
|
|
return a.id < b.id
|
|
end
|
|
end
|
|
end
|
|
table.sort(self.goods_list, sort_func)
|
|
end
|
|
|
|
function GuildModel:GetGuildShopGoodsList( )
|
|
return self.goods_list
|
|
end
|
|
|
|
-- 更新社团商店数据 40028
|
|
function GuildModel:UpdateGuildShopData( vo )
|
|
-- 如果还没有物品列表则不进行处理，直接通过40027协议获得最新的信息
|
|
if IsTableEmpty(self.goods_list) then return end
|
|
for k, v in ipairs(self.goods_list) do
|
|
if v.id == vo.id then
|
|
v.buy_num = v.buy_num + vo.num -- 注意这里服务端返回的是我刚刚买了几个
|
|
v.can_buy = v.type == GuildModel.ShopBuyType.NoLimit or v.buy_num < v.num
|
|
break
|
|
end
|
|
end
|
|
self:SortGuildShopData()
|
|
end
|
|
|
|
-- 更新社团经验值和等级 40029
|
|
function GuildModel:UpdateGuildExpAndLv( vo )
|
|
if not vo then return end
|
|
self.base_info.guild_lv = vo.guild_lv
|
|
self.base_info.guild_exp = vo.guild_exp
|
|
end
|
|
|
|
-- 单独更新社团成员的在线情况
|
|
function GuildModel:UpdateGuildMemberOnlineFlag(vo)
|
|
if vo and self.member_list then
|
|
for k, v in pairs(self.member_list) do
|
|
if v.role_id == vo.role_id then
|
|
v.online_flag = vo.online_flag
|
|
-- 前端根据在线状态直接更新离线时间
|
|
v.offline_time = v.online_flag ~= 1 and TimeUtil:getServerTime() or 0
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 获取社团合并信息 40032
|
|
function GuildModel:SetGuildMergeInfo( vo )
|
|
-- 新获得的合并信息是被其他社团申请合并的信息，则重置刷新红点的限制
|
|
for k, v in ipairs(vo.fapplys) do
|
|
if not self.guild_merge_apply_cache[v.guild_id] then
|
|
self.member_refresh_check = true
|
|
end
|
|
self.guild_merge_apply_cache[v.guild_id] = true
|
|
end
|
|
-- if self.guild_merge_info and self.guild_merge_info.iden ~= vo.iden and vo.iden == 2 then
|
|
-- self.member_refresh_check = true
|
|
-- end
|
|
self.guild_merge_info = vo
|
|
end
|
|
function GuildModel:GetGuildMergeInfo( )
|
|
return self.guild_merge_info
|
|
end
|
|
-- 清空社团合并请求的缓存
|
|
function GuildModel:ClearMergeInfoCache( )
|
|
self.guild_merge_info = nil
|
|
end
|
|
|
|
-- 获取社团拼单任务列表 40035
|
|
-- 拼单的规则比较杂，简单来讲首先是需要拿到35协议的拼单，每次选中一个拼单都要发送40036协议（opty：0）定位到拼单信息开始邀请社员
|
|
-- 邀请成员后，人满可以开始任务，也是发送40036协议（opty:1）
|
|
-- 完成任务后方可自动领取奖励，弹出结算界面，并进入感谢参与社员阶段
|
|
function GuildModel:SetGuildSpellListData(vo)
|
|
local sort_func = function ( a, b )
|
|
return a.order < b.order
|
|
end
|
|
table.sort(vo.guild_orders, sort_func)
|
|
|
|
self.guild_sl_data = vo
|
|
self:ChooseOrReqGreastestOrder()
|
|
end
|
|
|
|
-- 选出当前或者可切换的最高级的拼单
|
|
function GuildModel:ChooseOrReqGreastestOrder( )
|
|
-- 获取当前选中的拼单信息
|
|
local lastest_sl, get_cur_sl = nil, false
|
|
local highest_sl, highest_sl_color = nil, nil
|
|
local temp_cfg = nil
|
|
for k, v in ipairs(self.guild_sl_data.guild_orders) do
|
|
if v.state == 1 or v.state == 2 then
|
|
self.guild_cur_sl_order_data = v
|
|
self.guild_cur_sl_orderId = v.order
|
|
get_cur_sl = true
|
|
break
|
|
end
|
|
if v.state >= 3 and (not lastest_sl or lastest_sl.ftime < v.ftime) then
|
|
lastest_sl = v
|
|
end
|
|
temp_cfg = Config.Guildorder[v.cfg]
|
|
if temp_cfg and v.state == 0 and (not highest_sl_color or highest_sl_color < temp_cfg.color) then
|
|
highest_sl = v.order
|
|
highest_sl_color = temp_cfg.color
|
|
end
|
|
end
|
|
-- 如果没有当前进行中的拼单，则判断还有没有剩余次数，有的话自动接取最高级的拼单，否则固定最后一个拼单结果
|
|
if not get_cur_sl then
|
|
local total_num = self:GetGuildKvByKey("accept_limit").val
|
|
if self.guild_sl_data.ordered < total_num and highest_sl_color then
|
|
self:Fire(GuildModel.REQUEST_CCMD_EVENT, 40036, 0, highest_sl)
|
|
return false
|
|
else
|
|
self.guild_cur_sl_order_data = lastest_sl
|
|
self.guild_cur_sl_orderId = lastest_sl.order
|
|
return true
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
function GuildModel:GetGuildSpellListData( )
|
|
return self.guild_sl_data
|
|
end
|
|
|
|
-- 更新选中了的拼单列表信息 40036
|
|
function GuildModel:UpdateGuildSpellListDataStatus(vo)
|
|
if not vo then return end
|
|
|
|
self.guild_cur_sl_order_data = nil
|
|
self.guild_cur_sl_orderId = vo.order
|
|
|
|
if self.guild_sl_data and self.guild_sl_data.guild_orders then
|
|
-- state 订单状态0初始1选中(可拼单)2已出待完成3已完成可感谢4完全完成
|
|
for k, v in ipairs(self.guild_sl_data.guild_orders) do
|
|
if v.order == vo.order then
|
|
self.guild_cur_sl_order_data = v
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
function GuildModel:GetCurSelectedSpellListId( )
|
|
return self.guild_cur_sl_orderId
|
|
end
|
|
-- 获取当前已经选中的拼单数据
|
|
function GuildModel:GetCurSelectedSpellListData( )
|
|
return self.guild_cur_sl_order_data
|
|
end
|
|
|
|
-- 完成拼单更新数据 40040
|
|
function GuildModel:UpdateGuildSpellListFinish(vo)
|
|
if not vo then return end
|
|
if self.guild_sl_data and self.guild_sl_data.guild_orders then
|
|
-- state 订单状态0初始1选中(可拼单)2已出待完成3已完成可感谢4完全完成
|
|
for k, v in ipairs(self.guild_sl_data.guild_orders) do
|
|
if v.order == vo.order then
|
|
v.state = 3
|
|
if self.guild_cur_sl_orderId == vo.order then
|
|
self.guild_cur_sl_order_data = v
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 更新单个拼单数据
|
|
function GuildModel:UpdateGuildSpellListData(vo)
|
|
if not vo then return end
|
|
if self.guild_sl_data and self.guild_sl_data.guild_orders then
|
|
-- state 订单状态0初始1选中(可拼单)2已出待完成3已完成可感谢4完全完成
|
|
for k, v in ipairs(self.guild_sl_data.guild_orders) do
|
|
if v.order == vo.order then
|
|
v.state = vo.state
|
|
v.process = vo.process
|
|
v.limit = vo.limit
|
|
v.teams = vo.teams
|
|
local need_refresh = true
|
|
if v.state == 4 then
|
|
need_refresh = self:ChooseOrReqGreastestOrder()
|
|
end
|
|
if need_refresh and v.order == self.guild_cur_sl_orderId then
|
|
self.guild_cur_sl_order_data = v
|
|
self:Fire(GuildModel.UPDATE_SELECTED_GUILD_SL_DATA)
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 社团拼单邀请社团成员后，记录邀请时间做cd表现
|
|
function GuildModel:SetGuildSLInviteMemTime(role_id)
|
|
if role_id then
|
|
self.guild_sl_invite_time[role_id] = TimeUtil:getServerTime()
|
|
end
|
|
end
|
|
function GuildModel:GetGuildSLInviteMemTime(role_id)
|
|
return self.guild_sl_invite_time[role_id] or 0
|
|
end
|
|
-- 社团拼单是否邀请了假人
|
|
function GuildModel:GetGuildSLInvitedFakeRole( )
|
|
local bool = false
|
|
if self.guild_cur_sl_order_data then
|
|
for k, v in pairs(self.guild_cur_sl_order_data.teams) do
|
|
if v.role_id < 10 then
|
|
bool = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
-- 判断当前成员是否已经接受了邀请
|
|
function GuildModel:GetGuildSLMemInvited(role_id)
|
|
local bool = false
|
|
if self.guild_cur_sl_order_data and role_id then
|
|
for k, v in pairs(self.guild_cur_sl_order_data.teams) do
|
|
if v.role_id == role_id then
|
|
bool = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
-- 判断当前的拼单数据是否可以打开感谢界面
|
|
function GuildModel:OpenGuildSLThankView(order)
|
|
if self.guild_sl_data and self.guild_sl_data.guild_orders then
|
|
-- state 订单状态0初始1选中(可拼单)2已出待完成3已完成可感谢4完全完成
|
|
for k, v in ipairs(self.guild_sl_data.guild_orders) do
|
|
if v.order == order and v.state == 3 then
|
|
-- 构造打开感谢界面的数据
|
|
local vo = {
|
|
support_cfg_id = v.cfg,
|
|
order = v.order,
|
|
role_list = v.teams
|
|
}
|
|
self:Fire(GuildModel.OPEN_GUILD_SL_THANK_VIEW, true, vo)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 社团资金 40043
|
|
function GuildModel:UpdateGuildFunds(vo)
|
|
self.base_info = self.base_info or {}
|
|
self.base_info.guild_funds = vo.value
|
|
self.guild_funds = vo.value
|
|
end
|
|
function GuildModel:SetGuildFunds(funds)
|
|
self.guild_funds = funds
|
|
end
|
|
function GuildModel:GetGuildFunds()
|
|
return self.guild_funds
|
|
end
|
|
|
|
-- 更新玩家个人的社团活跃信息 40400
|
|
function GuildModel:SetPersonalGuildActive( vo )
|
|
self.personal_active = vo.labors
|
|
self.personal_stage = vo.stage
|
|
self.active_task = vo.labor_tasks
|
|
end
|
|
-- 获取社团个人活跃值和奖励阶段
|
|
function GuildModel:GetPersonalActiveInfo( )
|
|
return self.personal_active, self.personal_stage
|
|
end
|
|
function GuildModel:GetGuildActiveTaskData(id)
|
|
if id then
|
|
for k, v in pairs(self.active_task) do
|
|
if v.id == id then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
else
|
|
return self.active_task
|
|
end
|
|
end
|
|
|
|
-- 缓存社团驻地内玩家人数 40063
|
|
function GuildModel:SetGuildSceneMemberNum(num)
|
|
self.guild_scene_mem_num = num
|
|
self.guild_party_radio = 0
|
|
|
|
-- 获取人数挂机效率
|
|
for k, v in pairs(Config.Guildtriberadio) do
|
|
if v.num_min <= num and v.num_max >= num then
|
|
self.guild_party_radio = v.radio
|
|
end
|
|
end
|
|
end
|
|
function GuildModel:GetGuildSceneMemberNum( )
|
|
return self.guild_scene_mem_num, self.guild_party_radio
|
|
end
|
|
|
|
-- 更新社团活跃任务 40401
|
|
function GuildModel:UpdateActiveTask( vo )
|
|
for k, v in pairs(self.active_task) do
|
|
if v.id == vo.id and v.type == vo.type then
|
|
v.progress = vo.progress
|
|
v.state = vo.state
|
|
return
|
|
end
|
|
end
|
|
-- 若不能更新到任务，则在这边加入任务进度
|
|
local tb = {
|
|
id = vo.id,
|
|
type = vo.type,
|
|
progress = vo.progress,
|
|
state = vo.state,
|
|
}
|
|
table.insert(self.active_task, tb)
|
|
end
|
|
|
|
-- 更新社团总活跃度相关信息 40402
|
|
function GuildModel:SetGuildActiveData( vo )
|
|
self.guild_active = vo.labors
|
|
self.guild_active_stage = vo.stage
|
|
self.guild_week_stime = vo.stime
|
|
end
|
|
function GuildModel:GetGuildActiveData( )
|
|
return self.guild_active, self.guild_active_stage, self.guild_week_stime
|
|
end
|
|
|
|
-- 更新活跃奖励领取阶段 40403
|
|
function GuildModel:UpdateActiveStage( vo )
|
|
if vo.opty == 0 then -- 个人活跃奖励领取
|
|
self.personal_stage = vo.stage
|
|
elseif vo.opty == 1 then -- 社团阶段奖励领取
|
|
self.guild_active_stage = vo.stage
|
|
end
|
|
end
|
|
function GuildModel:GetAutoApproveData( )
|
|
return self.approve_type, self.auto_approve_lv, self.auto_approve_power
|
|
end
|
|
|
|
-- 服务端广播社团活跃值
|
|
function GuildModel:UpdateGuildActive(active)
|
|
self.guild_active = active
|
|
end
|
|
|
|
-- 设置社团日志信息 40404
|
|
function GuildModel:SetGuildLogInfo( vo )
|
|
vo = self:SortGuildLog(vo)
|
|
self.guild_log_list = vo
|
|
end
|
|
function GuildModel:SortGuildLog( list )
|
|
local sort_func = function ( a, b )
|
|
return a.time > b.time
|
|
end
|
|
table.sort(list, sort_func)
|
|
return list
|
|
end
|
|
function GuildModel:GetGuildLogInfo( )
|
|
return self.guild_log_list
|
|
end
|
|
|
|
-- 更新社团日志内容 40405
|
|
function GuildModel:UpdateGuildLogInfo( vo )
|
|
self.guild_log_list[#self.guild_log_list+1] = {
|
|
type = vo.type,
|
|
name = vo.name,
|
|
value = vo.value,
|
|
time = vo.time,
|
|
}
|
|
self.guild_log_list = self:SortGuildLog(self.guild_log_list)
|
|
end
|
|
|
|
-- 更新玩家个人活跃
|
|
function GuildModel:UpdateGuildActivePersonalActive(active)
|
|
self.personal_active = active
|
|
end
|
|
|
|
-- 社团活动玩法相关的数据添加(驻地内玩法)
|
|
-- 活动的类型需要在GuildEventType中注册
|
|
function GuildModel:SetGuildEventByType(type, vo)
|
|
if not type or not vo then return end
|
|
-- 使用同一个参数来标识活动的开启情况
|
|
vo.is_evt_open = false
|
|
if type == GuildEventType.GuildBossNoon then -- 社团午间boss
|
|
vo.is_evt_open = vo.state == 1
|
|
self.guild_event_tab_red["406@1"] = vo.is_evt_open
|
|
-- 主界面右上角入口按钮
|
|
if vo.is_evt_open then
|
|
local end_time = vo.stime + self:GetGuildEventStayTime(406, 1)
|
|
local left_time = end_time - TimeUtil:getServerTime()
|
|
ActivityIconManager:getInstance():addIcon(40601, left_time)
|
|
if not self.guild_event_act_tip_cache[type] then
|
|
if not SceneManager:getInstance():IsGuildScene() then
|
|
GlobalEventSystem:Fire(EventName.OPEN_ACITVITY_TIP,406,1,true)
|
|
end
|
|
self.guild_event_act_tip_cache[type] = true
|
|
end
|
|
else
|
|
ActivityIconManager:getInstance():deleteIcon(40601)
|
|
GlobalEventSystem:Fire(EventName.CLOSE_ACITVITY_TIP, 406, 1)
|
|
-- 活动结束后清除roll点数据
|
|
self:ClearGuildBossRollData(30)
|
|
end
|
|
elseif type == GuildEventType.GuildBossNight then -- 社团晚间boss
|
|
vo.is_evt_open = vo.state == 1
|
|
self.guild_event_tab_red["406@2"] = vo.is_evt_open
|
|
-- 主界面右上角入口按钮
|
|
if vo.is_evt_open then
|
|
local end_time = vo.stime + self:GetGuildEventStayTime(406, 1, 2)
|
|
local left_time = end_time - TimeUtil:getServerTime()
|
|
ActivityIconManager:getInstance():addIcon(40602, left_time)
|
|
if not self.guild_event_act_tip_cache[type] then
|
|
if not SceneManager:getInstance():IsGuildScene() then
|
|
GlobalEventSystem:Fire(EventName.OPEN_ACITVITY_TIP,406,2,true)
|
|
end
|
|
self.guild_event_act_tip_cache[type] = true
|
|
end
|
|
else
|
|
ActivityIconManager:getInstance():deleteIcon(40602)
|
|
GlobalEventSystem:Fire(EventName.CLOSE_ACITVITY_TIP, 406, 2)
|
|
-- 活动结束后清除roll点数据
|
|
self:ClearGuildBossRollData(30)
|
|
end
|
|
elseif type == GuildEventType.NoonCollect then -- 社团午间采集
|
|
vo.is_active = vo.state == 1
|
|
vo.is_evt_open = vo.state == 1
|
|
|
|
self.guild_evt_data[type] = vo--封印裂隙要先保存下数据，不然会导致邀请函开启控制失效
|
|
|
|
self.guild_event_tab_red["408@0"] = vo.is_evt_open
|
|
self.guild_event_tab_red["408@"..vo.type] = vo.is_evt_open
|
|
--展示主界面右上角活动通知图标
|
|
if vo.state == 1 then
|
|
local curTime = TimeUtil:getServerTime()
|
|
local status_time = vo.end_time - curTime
|
|
ActivityIconManager:getInstance():addIcon(40800, status_time)
|
|
--封印裂隙不再主动弹邀请函
|
|
-- if not self.guild_event_act_tip_cache[type] then
|
|
-- if not SceneManager:getInstance():IsGuildScene() then
|
|
-- if not self:GuildCollectAutoFightIgnoreCollectMon() then
|
|
-- GlobalEventSystem:Fire(EventName.OPEN_ACITVITY_TIP, 408,nil,true)
|
|
-- end
|
|
-- end
|
|
-- self.guild_event_act_tip_cache[type] = true
|
|
-- end
|
|
else
|
|
self.guild_event_act_tip_cache[type] = false
|
|
CommonModel:getInstance():ReSetActClockMaskList(408)
|
|
ActivityIconManager:getInstance():deleteIcon(40800)
|
|
GlobalEventSystem:Fire(EventName.CLOSE_ACITVITY_TIP, 408)
|
|
|
|
self:ResetSelfGuildCollectSupportId()
|
|
end
|
|
elseif type == GuildEventType.GuildParty then -- 社团派对
|
|
-- 需要额外判断活动是否已经开放
|
|
local is_module_open = GetModuleIsOpen(400, 7)
|
|
vo.is_evt_open = vo.stime ~= 0 and is_module_open
|
|
self.guild_event_tab_red["400@7"] = vo.is_evt_open
|
|
-- 主界面右上角入口按钮
|
|
if vo.is_evt_open then
|
|
local left_time = vo.etime - TimeUtil:getServerTime()
|
|
ActivityIconManager:getInstance():addIcon(4007, left_time)
|
|
if not self.guild_event_act_tip_cache[type] then
|
|
if not SceneManager:getInstance():IsGuildScene() then
|
|
GlobalEventSystem:Fire(EventName.OPEN_ACITVITY_TIP,400,7,true)
|
|
end
|
|
self.guild_event_act_tip_cache[type] = true
|
|
end
|
|
else
|
|
ActivityIconManager:getInstance():deleteIcon(4007)
|
|
GlobalEventSystem:Fire(EventName.CLOSE_ACITVITY_TIP, 400, 7)
|
|
end
|
|
elseif type == GuildEventType.GuildWar then -- 本服团战
|
|
local cur_time = TimeUtil:getServerTime()
|
|
vo.is_evt_open = vo.etime ~= 0 and vo.state == 1 and cur_time < vo.etime
|
|
self.guild_event_tab_red["405@1"] = vo.is_evt_open
|
|
if vo.is_evt_open then
|
|
local left_time = vo.etime - cur_time
|
|
ActivityIconManager:getInstance():addIcon(40501, left_time)
|
|
self:SetWarActiveRedDot(405, 1, true)
|
|
if not self.guild_event_act_tip_cache[type] then
|
|
GlobalEventSystem:Fire(EventName.OPEN_ACITVITY_TIP,405,nil,true)
|
|
self.guild_event_act_tip_cache[type] = true
|
|
end
|
|
else
|
|
self:SetWarActiveRedDot(405, 1, false)
|
|
ActivityIconManager:getInstance():deleteIcon(40501)
|
|
GlobalEventSystem:Fire(EventName.CLOSE_ACITVITY_TIP, 405)
|
|
end
|
|
elseif type == GuildEventType.GuildCSGR then -- 本国团战
|
|
vo.is_evt_open = vo.status ~= 0
|
|
if vo.is_evt_open then
|
|
ActivityIconManager:getInstance():addIcon(41000 + vo.ac_sub, vo.end_time - TimeUtil:getServerTime())
|
|
self:SetWarActiveRedDot(410, 1, true)
|
|
if not self.guild_event_act_tip_cache[type] then
|
|
GlobalEventSystem:Fire(EventName.OPEN_ACITVITY_TIP, 410, vo.ac_sub, true)
|
|
self.guild_event_act_tip_cache[type] = true
|
|
end
|
|
else
|
|
self:SetWarActiveRedDot(410, 1, false)
|
|
ActivityIconManager:getInstance():deleteIcon(41000 + vo.ac_sub)
|
|
GlobalEventSystem:Fire(EventName.CLOSE_ACITVITY_TIP, 410, vo.ac_sub)
|
|
end
|
|
if vo.status == 3 then -- 打开boss假血条表现
|
|
self:StartCSGRBossHpTimer()
|
|
end
|
|
end
|
|
self.guild_evt_data[type] = vo
|
|
end
|
|
|
|
function GuildModel:GetGuildEventByType(type)
|
|
return type and self.guild_evt_data[type]
|
|
end
|
|
|
|
function GuildModel:CheckGuildAuctionShow(vo)
|
|
self.guild_auction_hide = true
|
|
if vo.etime then
|
|
local cfg = self:LoadGuildAuctionCfg()
|
|
if cfg and cfg.e_time == vo.etime then
|
|
return
|
|
end
|
|
local time = TimeUtil:getServerTime()
|
|
if vo.etime > time and vo.etime <= time + 1800 +5 then
|
|
self.guild_auction_hide = false
|
|
self.guild_auction_time = vo.etime
|
|
end
|
|
end
|
|
end
|
|
|
|
function GuildModel:IsGuildAuctionShow()
|
|
return not self.guild_auction_hide
|
|
end
|
|
|
|
function GuildModel:SetGuildAuctionHide()
|
|
self.guild_auction_hide = true
|
|
self.guild_auction_cfg =
|
|
{
|
|
e_time = self.guild_auction_time,
|
|
}
|
|
self:SaveGuildAuctionCfg()
|
|
end
|
|
|
|
--保存社团拍卖提示
|
|
function GuildModel:SaveGuildAuctionCfg()
|
|
if self.guild_auction_cfg then
|
|
CookieWrapper.Instance:SaveCookie(CookieLevelType.Account, CookieTimeType.TYPE_ALWAYS, CookieKey.GUILD_SCENE_AUCION, self.guild_auction_cfg)
|
|
CookieWrapper.Instance:WriteAll()
|
|
end
|
|
end
|
|
|
|
--加载社团拍卖提示
|
|
function GuildModel:LoadGuildAuctionCfg()
|
|
self.guild_auction_cfg = CookieWrapper.Instance:GetCookie(CookieLevelType.Account, CookieKey.GUILD_SCENE_AUCION)
|
|
return self.guild_auction_cfg
|
|
end
|
|
|
|
--判断活动是否开启
|
|
function GuildModel:IsGuildEventActive(event_type)
|
|
return event_type and self.guild_evt_data[event_type] and self.guild_evt_data[event_type].is_evt_open or false
|
|
end
|
|
|
|
function GuildModel:GetGuildEventData()
|
|
return self.guild_evt_data
|
|
end
|
|
|
|
----------封印裂隙玩法---start
|
|
--传入开始时间的时，获取第几场
|
|
function GuildModel:GetActivityRound(s_h,s_m)
|
|
local act_list = Config.Ac["408@0@1"]
|
|
local time_list = stringtotable(act_list.time_region)
|
|
local max_length = #time_list
|
|
for i,v in ipairs(time_list) do--遍历场次
|
|
if tonumber(s_h) == tonumber(v[1][1]) and tonumber(s_m) == tonumber(v[1][2]) then
|
|
return i
|
|
end
|
|
end
|
|
return 0
|
|
end
|
|
|
|
--根据怪物id获取采集活动的协助奖励配置
|
|
function GuildModel:GetGuildCollectMonRewardCfgById(mon_id)
|
|
local cfg = config.Guildcollectmonrewards
|
|
return cfg[mon_id] or nil
|
|
end
|
|
|
|
--社团采集活动状态 40801（主推是04协议，01协议这里只用来请求结束时间）
|
|
function GuildModel:SetGuildCollectActivityState(vo)
|
|
self.is_collect_active = vo.state == 1 and true or false --午间采集当前是否开着
|
|
self.collect_end_time = vo.end_time --当前午间采集活动的结束时间戳
|
|
if vo.state == 1 then--活动开始时开始进行倒计时
|
|
self:SetCollectLeftTime(self.collect_end_time)
|
|
end
|
|
end
|
|
|
|
--社团采集活动状态 40804 (后端主推通知活动开始和结束)
|
|
function GuildModel:SetGuildCollectActivityState2(vo)
|
|
self.is_collect_active = vo.state == 1 and true or false --午间采集当前是否开着
|
|
end
|
|
|
|
--社团采集活动参与信息 40802
|
|
function GuildModel:SetGuildCollectActivityInfo(vo)
|
|
self.day_total_collect_times = vo.count--今日已采集总次数
|
|
end
|
|
|
|
--采集场景右上角信息 40803
|
|
function GuildModel:SetGuildCollectActivityDetailInfo(vo)
|
|
self.now_collect_seal_times = vo.count1 --本次封印活动采集次数
|
|
self.day_total_collect_times = vo.total_count--今日已采集总次数
|
|
end
|
|
|
|
--午间采集活动是否开启中
|
|
function GuildModel:IsGuildCollectActive( )
|
|
return self.is_collect_active
|
|
end
|
|
|
|
--获取当前采集的结束时间戳
|
|
function GuildModel:GetNowCollectEndTime( )
|
|
return self.collect_end_time
|
|
end
|
|
|
|
--获取本次封印活动的采集次数
|
|
function GuildModel:GetNowCollectSealTimes( )
|
|
return self.now_collect_seal_times
|
|
end
|
|
|
|
--获取封印活动今日已采集的总次数
|
|
function GuildModel:GetDayTotalCollectTimes( )
|
|
return self.day_total_collect_times
|
|
end
|
|
|
|
--午间采集活动倒计时
|
|
function GuildModel:SetCollectLeftTime(end_time)
|
|
self:StopGuildCollectTimer()
|
|
local function checkLeftTime()
|
|
self.collect_left_time = end_time - TimeUtil:getServerTime()
|
|
self:Fire(GuildModel.UPDATE_GUILD_COLLECT_LEFT_TIME, self.collect_left_time)
|
|
end
|
|
checkLeftTime()
|
|
|
|
local function onTimer()
|
|
checkLeftTime()
|
|
if self.collect_left_time <= 0 then
|
|
self:StopGuildCollectTimer()
|
|
end
|
|
end
|
|
if self.collect_left_time_id == nil then
|
|
if self.collect_left_time > 0 then
|
|
self.collect_left_time_id = GlobalTimerQuest:AddPeriodQuest(onTimer, 0.5, -1)
|
|
end
|
|
end
|
|
end
|
|
|
|
function GuildModel:StopGuildCollectTimer( )
|
|
self.collect_left_time = 0
|
|
if self.collect_left_time_id then
|
|
GlobalTimerQuest:CancelQuest(self.collect_left_time_id)
|
|
self.collect_left_time_id = nil
|
|
end
|
|
end
|
|
|
|
--是否能继续采集 当次次数封印次数已满或者活动次数已满不给采集
|
|
function GuildModel:CanCollect()
|
|
--单场次数
|
|
local MaxCollectSealTimes = self:GetGuildCollectKvByKey("collet_time").value
|
|
local bool_seal = self:GetNowCollectSealTimes() < MaxCollectSealTimes
|
|
--一天最多次数
|
|
local MaxDayCollectSealTimes = self:GetGuildCollectKvByKey("join_time_day").value
|
|
local bool_day = self:GetDayTotalCollectTimes() < MaxDayCollectSealTimes
|
|
|
|
local bool_activity = false
|
|
local nc_data = self:GetGuildEventByType(GuildEventType.NoonCollect)
|
|
if nc_data then
|
|
bool_activity = nc_data.is_evt_open
|
|
end
|
|
|
|
return bool_seal and bool_activity and bool_day
|
|
end
|
|
|
|
--判断不能采集的原因 1|本次次数满 2|今日次数满
|
|
function GuildModel:GetCanNotCollectReason( )
|
|
local MaxCollectSealTimes = self:GetGuildCollectKvByKey("collet_time").value
|
|
local bool_seal = self:GetNowCollectSealTimes() < MaxCollectSealTimes
|
|
|
|
local MaxDayCollectSealTimes = self:GetGuildCollectKvByKey("join_time_day").value
|
|
local bool_day = self:GetDayTotalCollectTimes() < MaxDayCollectSealTimes
|
|
|
|
--优先今日总次数
|
|
if not bool_day then
|
|
return 2
|
|
else
|
|
if not bool_seal then
|
|
return 1
|
|
end
|
|
end
|
|
return 0
|
|
end
|
|
|
|
--封印裂隙活动中时次数满是否忽略采集怪
|
|
function GuildModel:GuildCollectAutoFightIgnoreCollectMon( )
|
|
local bool_activity = false
|
|
local nc_data = self:GetGuildEventByType(GuildEventType.NoonCollect)
|
|
if nc_data then
|
|
bool_activity = nc_data.is_evt_open
|
|
end
|
|
if not bool_activity then --如果不在活动中，返回false，避免影响其他情况
|
|
return false
|
|
else--在活动中且次数满返回true
|
|
--单场活动最多10次
|
|
local MaxCollectSealTimes = self:GetGuildCollectKvByKey("collet_time").value
|
|
local bool_seal = self:GetNowCollectSealTimes() < MaxCollectSealTimes
|
|
--一天最多30次
|
|
local MaxDayCollectSealTimes = self:GetGuildCollectKvByKey("join_time_day").value
|
|
local bool_day = self:GetDayTotalCollectTimes() < MaxDayCollectSealTimes
|
|
if not bool_seal or not bool_day then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 1）保留“自动封印”按钮，该按钮仅控制是否采集
|
|
-- 2）自动挂机需要根据当前状态判断挂机行为
|
|
-- 1.无封印次数时，点击挂机仅打怪
|
|
-- 2.有封印次数时，且未选中怪物，未进入协助状态时，仅采集
|
|
-- 3.有封印次数时，选中怪物，则攻击该怪物，击杀后变为无目标状态，继续采集
|
|
-- 4.有封印次数时，点击协助，攻击协助对象怪物，击杀后变为无目标状态，继续采集
|
|
--新的封印裂隙自动采集逻辑
|
|
|
|
|
|
--剩余的采集怪数量
|
|
function GuildModel:SetGuildCollectLeftMon(vo)
|
|
self.now_left_collect_mon_count = vo.count
|
|
end
|
|
|
|
--获取剩余的采集怪数量
|
|
function GuildModel:GetGuildCollectLeftMon( )
|
|
return self.now_left_collect_mon_count
|
|
end
|
|
|
|
--封印裂隙协助者助战信息
|
|
function GuildModel:SetGuildCollectHelperInfo(data,remove_id)
|
|
if remove_id then
|
|
self.guild_collect_helper_info[remove_id] = nil
|
|
return
|
|
end
|
|
if not data then return end
|
|
self.guild_collect_helper_info[data.role_id] = data
|
|
end
|
|
|
|
--获取封印裂隙协助者助战信息
|
|
function GuildModel:GetCollectHelperInfo( )
|
|
return self.guild_collect_helper_info
|
|
end
|
|
|
|
--设置自动采集状态
|
|
function GuildModel:SetAutoGuildCollectState(bool)
|
|
self.auto_guild_collect_state = bool and 1 or 0
|
|
if not bool then
|
|
--取消自动采集时清空当前的选中对象
|
|
-- GlobalEventSystem:Fire(EventName.CANCEL_TO_COLLECT)
|
|
-- Scene.Instance:CancelClickTarget(nil,true) --把目标清掉
|
|
else
|
|
--切换到自动采集状态时，立刻过去寻路找采集怪
|
|
self:Fire(GuildModel.AUTO_FIND_WAY_TO_GUILD_COLLECT_MON)
|
|
end
|
|
end
|
|
|
|
--获取自动采集状态
|
|
function GuildModel:GetAutoGuildCollectState( )
|
|
return self.auto_guild_collect_state
|
|
end
|
|
|
|
--是否为自动采集状态
|
|
function GuildModel:IsAutoGuildCollectState()
|
|
return self.auto_guild_collect_state == 1
|
|
end
|
|
|
|
--保存当前的封印裂隙协助唯一id
|
|
function GuildModel:SetSelfGuildCollectSupportId(id)
|
|
self.now_guild_collect_support_id = id
|
|
end
|
|
|
|
function GuildModel:ResetSelfGuildCollectSupportId( )
|
|
self.now_guild_collect_support_id = 0
|
|
end
|
|
|
|
function GuildModel:GetSelfGuildCollectSupportId( )
|
|
return self.now_guild_collect_support_id
|
|
end
|
|
|
|
----------封印裂隙玩法---end
|
|
|
|
-- 社团boss相关
|
|
-- 获取社团boss血量数据
|
|
function GuildModel:GetGuildBossHp( )
|
|
return self.guild_boss_hp_data
|
|
end
|
|
|
|
-- 更新晚间boss伤害排行数据 40602 40603
|
|
function GuildModel:SetGuildBossRank(boss_type, rank_type, vo)
|
|
if not boss_type or not rank_type then return end
|
|
self:RankSortFunc(vo.hurt_list, "rank")
|
|
self.guild_boss_rank[boss_type] = self.guild_boss_rank[boss_type] or {}
|
|
--过滤掉列表中伤害为0的
|
|
self.guild_boss_rank[boss_type][rank_type] = {}
|
|
for i,v in ipairs(vo.hurt_list) do
|
|
if v.hurt ~= 0 then
|
|
table.insert(self.guild_boss_rank[boss_type][rank_type],v)
|
|
end
|
|
end
|
|
end
|
|
function GuildModel:GetGuildBossRank(boss_type, rank_type)
|
|
return self.guild_boss_rank[boss_type] and self.guild_boss_rank[boss_type][rank_type] or {}
|
|
end
|
|
|
|
-- 伤害排行排序
|
|
function GuildModel:RankSortFunc(list, val)
|
|
if not val then return end
|
|
local sort_func = function ( a, b )
|
|
return a[val] < b[val]
|
|
end
|
|
table.sort(list, sort_func)
|
|
end
|
|
|
|
-- 更新晚间boss个人排行信息 40604
|
|
function GuildModel:SetGuildBossPersonalRank(boss_type, vo)
|
|
self.guild_boss_personal_rank[boss_type] = self.guild_boss_personal_rank[boss_type] or {}
|
|
self.guild_boss_personal_rank[boss_type][vo.opty] = vo
|
|
end
|
|
function GuildModel:GetGuildBossPersonalRank(boss_type, type)
|
|
return self.guild_boss_personal_rank[boss_type] and self.guild_boss_personal_rank[boss_type][type] or nil
|
|
end
|
|
|
|
-- 对晚间boss活动的结算奖励和排行做排序
|
|
function GuildModel:SortGuildBossResult(vo)
|
|
-- 道具排序规则是品质降序，id升序
|
|
local good_basic
|
|
for k, v in pairs(vo.role_awards) do
|
|
good_basic = GoodsModel:getInstance():GetGoodsBasicByTypeId(v.goodsid)
|
|
v.color = good_basic.color
|
|
end
|
|
for k, v in pairs(vo.guild_awards) do
|
|
good_basic = GoodsModel:getInstance():GetGoodsBasicByTypeId(v.goodsid)
|
|
v.color = good_basic.color
|
|
end
|
|
local sort_goods = function ( a, b )
|
|
if a.color == b.color then
|
|
return a.goodsid < b.goodsid
|
|
else
|
|
return a.color > b.color
|
|
end
|
|
end
|
|
if vo.role_awards and TableSize(vo.role_awards) > 1 then
|
|
table.sort(vo.role_awards, sort_goods)
|
|
end
|
|
if vo.guild_awards and TableSize(vo.guild_awards) > 1 then
|
|
table.sort(vo.guild_awards, sort_goods)
|
|
end
|
|
end
|
|
|
|
function GuildModel:SetGuildBossInvincible(vo)
|
|
self.guild_boss_invincible = vo
|
|
end
|
|
function GuildModel:GetGuildBossInvincible( )
|
|
return self.guild_boss_invincible
|
|
end
|
|
|
|
-- 获得boss坐标
|
|
function GuildModel:GetGuildBossPos( )
|
|
local pos_data = stringtotable(Config.Guildbosskv["mon_pos"].value)
|
|
return pos_data[1],pos_data[2]
|
|
end
|
|
-- 设置boss血量（伪，并非真血量，而是用于显示血条的模拟）
|
|
function GuildModel:SetGuildBossHpSimulation(hp)
|
|
self.guild_boss_hp_sim = hp
|
|
self:ChangeVar("guild_boss_hp_sim", hp,false,true)
|
|
end
|
|
function GuildModel:GetGuildBossHpSimulation( )
|
|
return self.guild_boss_hp_sim
|
|
end
|
|
|
|
--社团boss鼓舞数据 40607
|
|
function GuildModel:SetGuildBossEncourageData(vo)
|
|
self:ChangeVar("encourage_free_times", vo.free_times, false, true)
|
|
self:ChangeVar("encourage_cost_times", vo.cost_times, false, true)
|
|
self:ChangeVar("encourage_guild_times", vo.guild_times, false, true)
|
|
end
|
|
|
|
--广播更新社团鼓舞次数 40609
|
|
function GuildModel:UpdateGuildBossEncourageGuildTimes(vo)
|
|
self:ChangeVar("encourage_guild_times", vo.guild_times, false, true)
|
|
end
|
|
|
|
-- 设置当前社团采集的道具id
|
|
function GuildModel:SetCurGuildBossCollectDropId(drop_id)
|
|
self.gboss_col_drop_id = drop_id
|
|
end
|
|
|
|
function GuildModel:GetCurGuildBossCollectDropId( )
|
|
return self.gboss_col_drop_id
|
|
end
|
|
|
|
--获取剩余的免费鼓舞次数
|
|
function GuildModel:GetLeftFreeEncourageTimes( )
|
|
return self.encourage_free_times
|
|
end
|
|
|
|
--获取剩余的付费鼓舞次数
|
|
function GuildModel:GetleftCostEncourageTimes( )
|
|
return self.encourage_cost_times
|
|
end
|
|
|
|
--获取社团鼓舞加成次数
|
|
function GuildModel:GetEncourageGuildTimes( )
|
|
return self.encourage_guild_times
|
|
end
|
|
|
|
function GuildModel:CacheGuildIgnoreCollectId(instance_id)
|
|
self.guild_collect_ignore_list[instance_id] = true
|
|
end
|
|
function GuildModel:ClearGuildIgnoreCollectId(instance_id)
|
|
if self.guild_collect_ignore_list[instance_id] then
|
|
self.guild_collect_ignore_list[instance_id] = nil
|
|
end
|
|
end
|
|
function GuildModel:IsGuildIgnoreCollection(instance_id)
|
|
return self.guild_collect_ignore_list[instance_id]
|
|
end
|
|
function GuildModel:ClearGuildIgnoreCollection( )
|
|
self.guild_collect_ignore_list = {}
|
|
end
|
|
-- 社团boss roll点数据缓存 每一轮roll点重置并刷新 40613
|
|
function GuildModel:SetGuildBossRollData(vo)
|
|
self:ClearGuildBossRollData()
|
|
self.guild_boss_roll_start_time = vo.start_time
|
|
self.guild_boss_roll_data_raw = vo.roll_list
|
|
for k, v in ipairs(vo.roll_list) do
|
|
self.guild_boss_roll_data[v.order_id] = v
|
|
end
|
|
end
|
|
function GuildModel:GetGuildBossRollStartTime( )
|
|
return self.guild_boss_roll_start_time
|
|
end
|
|
function GuildModel:GetGuildBossRollData( )
|
|
return self.guild_boss_roll_data_raw
|
|
end
|
|
-- 根据id获取roll点数据
|
|
function GuildModel:GetGuildBossRollDataByOrderId(order_id)
|
|
if not order_id then return end
|
|
return self.guild_boss_roll_data[order_id] or nil
|
|
end
|
|
-- 清除社团bossroll点缓存数据 delay_sec 是否延迟
|
|
function GuildModel:ClearGuildBossRollData(delay_sec)
|
|
if self.delay_clear_gboss_roll_data_id then
|
|
GlobalTimerQuest:CancelQuest(self.delay_clear_gboss_roll_data_id)
|
|
self.delay_clear_gboss_roll_data_id = nil
|
|
end
|
|
if delay_sec then
|
|
local function delay_method( )
|
|
self:ClearGuildBossRollData()
|
|
end
|
|
self.delay_clear_gboss_roll_data_id = setTimeout(delay_method, delay_sec)
|
|
else
|
|
self.guild_boss_roll_data_raw = {}
|
|
self.guild_boss_roll_data = {}
|
|
self.guild_boss_role_highest_roleId = {}
|
|
self.guild_boss_roll_record = {}
|
|
self:SetGuildBossRollIsFinished(false)
|
|
end
|
|
end
|
|
-- 根据roll点结果，更新缓存 40614
|
|
function GuildModel:UpdateGuildBossRollData(vo)
|
|
if vo then
|
|
for k, v in pairs(self.guild_boss_roll_data_raw) do
|
|
if v.order_id == vo.order_id then
|
|
v.roll_num = vo.roll_num
|
|
break
|
|
end
|
|
end
|
|
if self.guild_boss_roll_data[vo.order_id] then
|
|
self.guild_boss_roll_data[vo.order_id].roll_num = vo.roll_num
|
|
end
|
|
end
|
|
end
|
|
|
|
function GuildModel:SetGuildBossRollIsFinished(bool)
|
|
self.guild_boss_roll_finished = bool
|
|
end
|
|
function GuildModel:GetGuildBossRollIsFinished( )
|
|
return self.guild_boss_roll_finished
|
|
end
|
|
-- 获取社团boss的玩家roll点次数红点
|
|
function GuildModel:CheckGuildBossNumRed( )
|
|
self.g_boss_roll_red_num = 0
|
|
local cur_time = TimeUtil:getServerTime()
|
|
local roll_delay_time = self:GetGuildBossKV("roll_time") -- 几秒后结束roll点
|
|
if not self.guild_boss_roll_finished then -- 如果roll点阶段内，则判断有几个道具没有roll
|
|
for k, v in pairs(self.guild_boss_roll_data_raw) do
|
|
if (cur_time < (self.guild_boss_roll_start_time + roll_delay_time)) and v.roll_num == 0 then
|
|
self.g_boss_roll_red_num = self.g_boss_roll_red_num + 1
|
|
end
|
|
end
|
|
else -- 如果roll点阶段外，则判断是否需要提示获得了几件道具
|
|
if self._gboss_need_show_claim_red then
|
|
local role_id = RoleManager.Instance.mainRoleInfo.role_id
|
|
for k, v in pairs(self.guild_boss_role_highest_roleId) do
|
|
if v == role_id then
|
|
self.g_boss_roll_red_num = self.g_boss_roll_red_num + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return self.g_boss_roll_red_num
|
|
end
|
|
function GuildModel:GetGuildBossNumRed( )
|
|
return self.g_boss_roll_red_num
|
|
end
|
|
|
|
-- 查询roll点信息 40616
|
|
function GuildModel:SetGuildBossRollRecord(vo)
|
|
if vo then
|
|
self.guild_boss_roll_record[vo.order_id] = vo.role_list
|
|
end
|
|
if self.guild_boss_roll_finished then
|
|
self:GetGuildBossRollHighestRoleId(vo.order_id)
|
|
end
|
|
end
|
|
function GuildModel:GetGuildBossRollRecord(order_id)
|
|
if order_id then
|
|
return self.guild_boss_roll_record[order_id]
|
|
end
|
|
end
|
|
|
|
-- 当本轮roll点结束后，调用此方法，计算一次缓存中所有的记录的最高玩家id update_order_id 只更新目标id
|
|
function GuildModel:GetGuildBossRollHighestRoleId(update_order_id)
|
|
for order_id, record_list in pairs(self.guild_boss_roll_record) do
|
|
if not update_order_id or update_order_id == order_id then
|
|
local highest_roll_num, target_role_id = nil, 0
|
|
for k, record in pairs(record_list) do
|
|
if not highest_roll_num or highest_roll_num < record.roll_num then
|
|
highest_roll_num = record.roll_num
|
|
target_role_id = record.role_id
|
|
end
|
|
end
|
|
self.guild_boss_role_highest_roleId[order_id] = target_role_id
|
|
end
|
|
end
|
|
self:Fire(GuildModel.UPDATE_GUILD_BOSS_HIGHEST_DATA, update_order_id or nil)
|
|
end
|
|
-- 根据id获取本轮roll点点数最高的玩家id
|
|
function GuildModel:GetGuildBossRollHighestByOrderId(order_id)
|
|
if not order_id then return 0 end
|
|
return self.guild_boss_role_highest_roleId[order_id] or 0
|
|
end
|
|
|
|
-- 缓存数据，定时发送特殊社团聊天内容
|
|
-- function GuildModel:CacheGuildBossRollResult(vo, roll_num, max_roll)
|
|
-- if vo and roll_num and max_roll then
|
|
-- -- print("Saber:GuildModel [start:2057] ------------------------------------------")
|
|
-- table.insert(self.gboss_roll_result, {
|
|
-- goods_type_id = vo.goods_type_id,
|
|
-- num = vo.num,
|
|
-- roll_num = roll_num,
|
|
-- max_roll = max_roll,
|
|
-- })
|
|
-- self:LoadGuildBossRollResult()
|
|
-- end
|
|
-- end
|
|
-- -- 读取roll点缓存，发送玩家名义的roll点聊天内容
|
|
-- function GuildModel:LoadGuildBossRollResult( )
|
|
-- if not self.is_in_gboss_result_cd then
|
|
-- local vo = table.remove(self.gboss_roll_result, 1)
|
|
-- if vo then
|
|
-- -- print("Saber:GuildModel [start:2072] ------------------------------------------")
|
|
-- local goods_name = GoodsModel:getInstance():getGoodsName(vo.goods_type_id, true)
|
|
-- ChatModel:getInstance():Fire(
|
|
-- ChatModel.SEND_MSG, ChatModel.CHANNEL_GUILD,
|
|
-- string.format("我在<color=%s>[社团幻魔]</color>中对%s掷出了<color=%s>%s</color>点（当前最高<color=%s>%s</color>点）",
|
|
-- ColorUtil.BLUE_DARK, goods_name, ColorUtil.GREEN_DARK, vo.roll_num, ColorUtil.GREEN_DARK, vo.max_roll),
|
|
-- 0, "[{notcd, 1}]")
|
|
-- -- 毫秒计时 多延迟100毫秒
|
|
-- local cd_end_time = TimeUtil:getServerTimeMs() + 100
|
|
-- local function gboss_roll_result_cdtimer()
|
|
-- local cd_finished = cd_end_time < TimeUtil:getServerTimeMs()
|
|
-- if cd_finished then
|
|
-- -- print("Saber:GuildModel [start:2084] ------------------------------------------")
|
|
-- self:ClearGuildBossRollResultCDTimer()
|
|
-- self.is_in_gboss_result_cd = false
|
|
-- self:LoadGuildBossRollResult()
|
|
-- end
|
|
-- end
|
|
-- self.gboss_roll_result_cdtimer_id = GlobalTimerQuest:AddPeriodQuest(gboss_roll_result_cdtimer, 0.01, -1)
|
|
-- self.is_in_gboss_result_cd = true
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- function GuildModel:ClearGuildBossRollResultCDTimer( )
|
|
-- if self.gboss_roll_result_cdtimer_id then
|
|
-- GlobalTimerQuest:CancelQuest(self.gboss_roll_result_cdtimer_id)
|
|
-- self.gboss_roll_result_cdtimer_id = nil
|
|
-- end
|
|
-- end
|
|
-- 社团boss相关 end
|
|
|
|
-- 社团派对相关
|
|
-- 缓存社团派对经验和祝火状态 40058
|
|
function GuildModel:SetGuildPartyExpData(vo)
|
|
self.guild_party_exp = vo.exp
|
|
-- self.guild_party_pos = vo.pos
|
|
end
|
|
function GuildModel:GetGuildPartyExpData( )
|
|
return self.guild_party_exp
|
|
end
|
|
|
|
-- 更新社团派对的经验值 40059
|
|
function GuildModel:UpdateGuildPartyExp(vo)
|
|
self.guild_party_exp = self.guild_party_exp + vo.exp
|
|
self.guild_party_exp_eff = vo.exp * 12 -- 这个经验值是5秒给一次，这里计算一次每分钟的经验值
|
|
if self.guild_evt_data[GuildEventType.GuildParty] then
|
|
self.guild_evt_data[GuildEventType.GuildParty].ltime = vo.ltime
|
|
end
|
|
end
|
|
function GuildModel:GetGuildPartyExpEffPerMin( )
|
|
return self.guild_party_exp_eff
|
|
end
|
|
--设置社团协助信息前往协助列表 40046
|
|
function GuildModel:SetGuildSupportInfo( scmd )
|
|
self.guild_support_info = scmd.support_list
|
|
|
|
--判断当前唯一协助id是不是封印裂隙的
|
|
for k,v in pairs(self.guild_support_info) do
|
|
if scmd.self_support_sid == v.support_sid and v.support_cfg_id == 2 then
|
|
self:SetSelfGuildCollectSupportId(scmd.self_support_sid)
|
|
end
|
|
end
|
|
end
|
|
|
|
function GuildModel:GetGuildSupportInfo( )
|
|
return self.guild_support_info
|
|
end
|
|
|
|
--通过sid获取某一个协助
|
|
function GuildModel:GetGuildSupportInfoById( support_sid )
|
|
local list = self:GetGuildSupportInfo()
|
|
local info
|
|
if list and #list > 0 then
|
|
for i,v in ipairs(list) do
|
|
if v.support_sid == support_sid then
|
|
info = v
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return info
|
|
end
|
|
|
|
--解析协助状态信息
|
|
function GuildModel:ParseGuildSupportData(str)
|
|
local bosspower = 0
|
|
local end_time = 0
|
|
local boss_id = 0
|
|
local dun_id = 0
|
|
local status = 0
|
|
if str and str ~= "" then
|
|
local info = stringtotable(str)
|
|
if info and #info > 0 then
|
|
for i,v in ipairs(info) do
|
|
local key = tonumber(v[1])
|
|
if key == 1 then
|
|
bosspower = tonumber(v[2])
|
|
elseif key == 2 then
|
|
end_time = tonumber(v[2])
|
|
elseif key == 3 then
|
|
boss_id = tonumber(v[2])
|
|
elseif key == 4 then
|
|
dun_id = tonumber(v[2])
|
|
elseif key == 5 then
|
|
status = tonumber(v[2])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return bosspower, end_time, boss_id, dun_id, status
|
|
end
|
|
|
|
|
|
--社团协助列表增删（封印裂隙40811）
|
|
function GuildModel:UpdateGuildSupportInfo(vo)
|
|
-- print("==WQ==:UpdateGuildSupportInfo [start:2039] self.guild_support_info:", self.guild_support_info)
|
|
-- PrintTable(self.guild_support_info)
|
|
-- print("==WQ==:GuildModel [end]")
|
|
if vo.type == 1 then--新增协助
|
|
--先防止加入相同id的协助
|
|
local have_same = false
|
|
for k,v in pairs(self.guild_support_info) do
|
|
if v.support_sid == vo.support_sid then
|
|
break
|
|
end
|
|
end
|
|
if have_same then return end
|
|
--把新增的数据插入进去
|
|
vo.type = nil
|
|
table.insert(self.guild_support_info,vo)
|
|
elseif vo.type == 2 then--删除协助
|
|
if vo.support_sid == 0 then--如果id是0，则要把列表中所有的封印裂隙协助删除
|
|
for k,v in pairs(self.guild_support_info) do
|
|
if v.support_cfg_id == 2 then
|
|
self.guild_support_info[k] = nil
|
|
end
|
|
end
|
|
else
|
|
for k,v in pairs(self.guild_support_info) do
|
|
if v.support_sid == vo.support_sid then
|
|
self.guild_support_info[k] = nil
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
self:Fire(GuildModel.UPDATE_GUILD_COLLECT_SUPPORT_INFO_LIST)
|
|
end
|
|
|
|
--设置自己当前协助唯一ID 40046
|
|
function GuildModel:SetSelfGuildSupportId( self_support_sid )
|
|
self.self_support_sid = self_support_sid
|
|
end
|
|
function GuildModel:GetSelfGuildSupportId( )
|
|
return self.self_support_sid
|
|
end
|
|
|
|
--协助状态 40046
|
|
function GuildModel:SetGuildSupportStatus( value )
|
|
self.self_support_status = value
|
|
end
|
|
function GuildModel:GetGuildSupportStatus( )
|
|
return self.self_support_status
|
|
end
|
|
--获得自己当前玩法的协助配置ID
|
|
function GuildModel:GetSelfServerSupportCfgId( )
|
|
local list = self:GetGuildSupportInfo()
|
|
local self_id = self:GetSelfGuildSupportId()
|
|
for i,v in ipairs(list) do
|
|
if v.support_sid == self_id then
|
|
return v.support_cfg_id
|
|
end
|
|
end
|
|
end
|
|
|
|
--获取当前自己的协助他人要攻击的 boss_id
|
|
function GuildModel:GetGuildSupportBossId( )
|
|
local boss_id = 0
|
|
local support_info = self:GetCurSupportPlayerInfo( )
|
|
if support_info then
|
|
return support_info.boss_id
|
|
end
|
|
return boss_id
|
|
end
|
|
|
|
--设置个人协助奖励 40047
|
|
function GuildModel:SetGuildSupportAwardInfo( scmd )
|
|
if not self.guild_support_award_info then self.guild_support_award_info = {} end
|
|
self.guild_support_award_info[#self.guild_support_award_info + 1] = scmd
|
|
end
|
|
function GuildModel:GetGuildSupportAwardInfo( )
|
|
return self.guild_support_award_info[1]
|
|
end
|
|
|
|
--当前感谢的礼包唯一ID 40048
|
|
function GuildModel:SetGuildSupportThankId( guild_support_thank_cfg_id )
|
|
self.guild_support_thank_cfg_id = guild_support_thank_cfg_id
|
|
end
|
|
--得到感谢的礼包唯一ID
|
|
function GuildModel:GetGuildSupportThankId( )
|
|
return self.guild_support_thank_cfg_id
|
|
end
|
|
|
|
--当前感谢界面信息 40049
|
|
function GuildModel:SetGuildSupportThankInfo( scmd )
|
|
self.guild_support_thank_info = scmd
|
|
end
|
|
--当前感谢界面信息
|
|
function GuildModel:GetGuildSupportThankInfo( )
|
|
return self.guild_support_thank_info
|
|
end
|
|
|
|
--设置玩家每日获得的名望券 40046(弃用20200817)
|
|
function GuildModel:SetDaliyReputation( guild_daliy_reputation )
|
|
-- if not self.guild_daliy_reputation then
|
|
-- self.guild_daliy_reputation = guild_daliy_reputation
|
|
-- else
|
|
-- if guild_daliy_reputation > self.guild_daliy_reputation then
|
|
-- local goods_name = GoodsModel:getInstance():getGoodsName(Config.ConfigNotNormalGoods[4].goods_id)
|
|
-- local str = string.format("%s增加<color=#10aaf1>%s</color>",goods_name,guild_daliy_reputation - self.guild_daliy_reputation)
|
|
-- -- Message.show(str)
|
|
-- end
|
|
-- self.guild_daliy_reputation = guild_daliy_reputation
|
|
-- end
|
|
end
|
|
|
|
-- 根据协议返回的协助唯一id，判断是否可以弹出拼单感谢界面
|
|
function GuildModel:ShowGuildSpellListThankView(support_id, option_type)
|
|
self.cur_guild_spelllist_thankId = support_id or self.cur_guild_spelllist_thankId
|
|
if not self.cur_guild_spelllist_thankId then return end
|
|
|
|
-- 是否在社团拼单界面，不是则什么也不操作
|
|
if not self._is_in_guild_spelllist_view then
|
|
return
|
|
end
|
|
-- 根据唯一协助id获取相应类型的支援数据
|
|
local support_data = self:GetSupportThankDataByTypeAndId(GuildModel.SupportThankType.SpellList, self.cur_guild_spelllist_thankId)
|
|
if support_data then
|
|
self:Fire(GuildModel.OPEN_GUILD_SL_THANK_VIEW, true, support_data)
|
|
end
|
|
end
|
|
-- 清除当前缓存的缓存感谢协助id
|
|
function GuildModel:ClearGuildSpellListCurSupportThankId( )
|
|
self.cur_guild_spelllist_thankId = nil
|
|
end
|
|
|
|
--获得协助玩家信息
|
|
function GuildModel:GetCurSupportPlayerInfo( )
|
|
local self_support_sid = self:GetSelfGuildSupportId()
|
|
local info = self:GetGuildSupportInfo()
|
|
for k,v in pairs(info) do
|
|
if v.support_sid == self_support_sid then
|
|
return v
|
|
end
|
|
end
|
|
end
|
|
|
|
--设置协助感谢列表
|
|
function GuildModel:SetSupportThankList( list )
|
|
self.support_thank_list = {}
|
|
local no_send_list = {}
|
|
local is_send_list = {}
|
|
local red_bool = false
|
|
if #list > 0 then
|
|
for i,v in ipairs(list) do
|
|
if v.is_send == 1 then
|
|
is_send_list[#is_send_list + 1] = v
|
|
else
|
|
no_send_list[#no_send_list + 1] = v
|
|
end
|
|
end
|
|
local sort_func = function ( a, b )--最新的要排在最前面
|
|
return a.support_id > b.support_id
|
|
end
|
|
if #no_send_list > 0 then
|
|
if #no_send_list > 1 then
|
|
table.sort(no_send_list, sort_func)
|
|
end
|
|
for i,v in ipairs(no_send_list) do
|
|
self.support_thank_list[#self.support_thank_list + 1] = v
|
|
end
|
|
red_bool = true
|
|
end
|
|
if #is_send_list > 0 then
|
|
if #is_send_list > 1 then
|
|
table.sort(is_send_list, sort_func)
|
|
end
|
|
for i,v in ipairs(is_send_list) do
|
|
self.support_thank_list[#self.support_thank_list + 1] = v
|
|
end
|
|
end
|
|
end
|
|
self.support_red_list[GuildModel.SupportTab.Thank] = red_bool
|
|
self:UpdateSupportMainIconRedDot()
|
|
-- 检查当前是否可以弹出感谢界面
|
|
self:ShowGuildSpellListThankView()
|
|
self:Fire(GuildModel.UPDATE_SUPPORT_THANK_LIST)
|
|
end
|
|
|
|
--获得协助感谢列表
|
|
function GuildModel:GetSupportThankList( )
|
|
return self.support_thank_list
|
|
end
|
|
|
|
-- 根据指定类型和协助id获取协助数据
|
|
function GuildModel:GetSupportThankDataByTypeAndId(type, support_id)
|
|
if type and support_id then
|
|
for k, v in pairs(self.support_thank_list) do
|
|
if v.type == type and v.support_id == support_id then
|
|
return v
|
|
end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--设置协助感谢领取列表
|
|
function GuildModel:SetSupportGiftList( list )
|
|
self.support_gift_list = {}
|
|
local no_get_list = {}
|
|
local is_get_list = {}
|
|
local red_bool = false
|
|
if #list > 0 then
|
|
for i,v in ipairs(list) do
|
|
if v.is_get == 1 then
|
|
is_get_list[#is_get_list + 1] = v
|
|
else
|
|
no_get_list[#no_get_list + 1] = v
|
|
end
|
|
end
|
|
local sort_func = function ( a, b )--最新的要排在最前面
|
|
return a.support_id > b.support_id
|
|
end
|
|
if #no_get_list > 0 then
|
|
if #no_get_list > 1 then
|
|
table.sort(no_get_list, sort_func)
|
|
end
|
|
for i,v in ipairs(no_get_list) do
|
|
self.support_gift_list[#self.support_gift_list + 1] = v
|
|
end
|
|
red_bool = true
|
|
end
|
|
if #is_get_list > 0 then
|
|
if #is_get_list > 1 then
|
|
table.sort(is_get_list, sort_func)
|
|
end
|
|
for i,v in ipairs(is_get_list) do
|
|
self.support_gift_list[#self.support_gift_list + 1] = v
|
|
end
|
|
end
|
|
end
|
|
self.support_red_list[GuildModel.SupportTab.Gift] = red_bool
|
|
self:UpdateSupportMainIconRedDot()
|
|
self:Fire(GuildModel.UPDATE_SUPPORT_GIFT_LIST)
|
|
end
|
|
|
|
--获得协助感谢列表
|
|
function GuildModel:GetSupportGiftList( )
|
|
return self.support_gift_list
|
|
end
|
|
|
|
--更新协助主界面icon红点
|
|
function GuildModel:UpdateSupportMainIconRedDot( )
|
|
local red_bool = false
|
|
for i,v in pairs(self.support_red_list) do
|
|
if v then
|
|
red_bool = true
|
|
break
|
|
end
|
|
end
|
|
if self.support_red_list[GuildModel.SupportTab.List] and RoleManager.Instance.mainRoleInfo.level >= 96 and not self.support_is_self_send then--自己发的不需要SOS
|
|
MsgManager:getInstance():Add({type=Config.ConfigMainIcon.TipType.support},have_red)
|
|
else
|
|
MsgManager:getInstance():Remove(Config.ConfigMainIcon.TipType.support)
|
|
end
|
|
if self.support_red_list[GuildModel.SupportTab.Thank] then
|
|
else
|
|
self:Fire(GuildModel.CLOSE_GUILD_SUPPORT_TIP_VIEW)
|
|
end
|
|
GlobalEventSystem:Fire(EventName.REFRESH_MAIN_UI_SUPPORT_RED_DOT, red_bool)
|
|
|
|
if self.support_is_self_send then
|
|
self.support_is_self_send = false
|
|
end
|
|
end
|
|
|
|
-- 本国团战相关协议 start
|
|
-- 设置本轮团战与玩家对战的社团信息 41001
|
|
function GuildModel:SetCSGRFightInfo(vo)
|
|
self.csgr_fight_info = vo.arena_list[1]
|
|
-- 置顶自己的社团
|
|
local guild_id = RoleManager.Instance.mainRoleInfo.guild_id
|
|
local sort_func = function ( a, b )
|
|
if a.guild_id ~= guild_id and b.guild_id ~= guild_id then
|
|
return a.guild_id < b.guild_id
|
|
else
|
|
return a.guild_id == guild_id
|
|
end
|
|
end
|
|
|
|
if self.csgr_fight_info and self.csgr_fight_info.guilds then
|
|
table.sort(self.csgr_fight_info.guilds, sort_func)
|
|
end
|
|
end
|
|
function GuildModel:GetCSGRFightInfo( )
|
|
return self.csgr_fight_info
|
|
end
|
|
|
|
-- 更新本国团战采集buff信息 41003
|
|
function GuildModel:SetCSGRCollectBuffs(vo)
|
|
if not vo then return end
|
|
self.csgr_collect_buff = {}
|
|
for k, v in ipairs(vo.buff_goods) do
|
|
self.csgr_collect_buff[v.attr_id] = v
|
|
end
|
|
end
|
|
function GuildModel:GetCSGRCollectBuffs(attr_id)
|
|
if not attr_id then
|
|
return self.csgr_collect_buff
|
|
else
|
|
return self.csgr_collect_buff[attr_id]
|
|
end
|
|
end
|
|
|
|
-- 更新本国团战战场物资信息 41004
|
|
function GuildModel:SetCSGRBattlefieldRes(vo)
|
|
if not vo then return end
|
|
self.csgr_bf_res = {}
|
|
for k, v in ipairs(vo.resources) do
|
|
self.csgr_bf_res[v.attr_id] = v
|
|
end
|
|
self.csgr_bf_res_refreshtime = vo.next_time
|
|
end
|
|
function GuildModel:GetCSGRBattlefieldRes(attr_id)
|
|
if not attr_id then
|
|
return self.csgr_bf_res
|
|
else
|
|
return self.csgr_bf_res[attr_id]
|
|
end
|
|
end
|
|
function GuildModel:GetCSGRBattlefieldResRefreshTime( )
|
|
return self.csgr_bf_res_refreshtime
|
|
end
|
|
|
|
-- 筛选出距离玩家最近的坐标点前往
|
|
function GuildModel:CSGRAutoFindCollection(vo)
|
|
if not vo then return end
|
|
local scene_mgr = SceneManager:getInstance()
|
|
if not scene_mgr:IsGuildCSGRScene() then return end
|
|
local getDistance = GameMath.GetDistance
|
|
local main_vo = Scene:getInstance():GetMainRole()
|
|
local x, y = main_vo:GetRealPos()
|
|
local min_dis, temp_dis, min_dis_pos
|
|
-- 算出距离玩家坐标最短的坐标点
|
|
for k, attr_pos in ipairs(vo.coordinates) do
|
|
temp_dis = getDistance(x, y, attr_pos.x, attr_pos.y, false)
|
|
if not min_dis or min_dis > temp_dis then
|
|
min_dis = temp_dis
|
|
min_dis_pos = attr_pos
|
|
end
|
|
end
|
|
if min_dis_pos then
|
|
local function call_back()
|
|
GlobalEventSystem:Fire(EventName.STARTAUTOFIGHT)
|
|
end
|
|
local findVo = FindVo.New()
|
|
findVo.type = FindVo.MONSTER
|
|
findVo.x = min_dis_pos.x / SceneObj.LogicRealRatio.x
|
|
findVo.y = min_dis_pos.y / SceneObj.LogicRealRatio.y
|
|
findVo.sceneId = scene_mgr:GetSceneId()
|
|
findVo.id = vo.attr_id
|
|
findVo.call_back = call_back
|
|
GlobalEventSystem:Fire(EventName.FIND, findVo)
|
|
end
|
|
end
|
|
|
|
-- 本国团战结算信息 41007
|
|
function GuildModel:SetGuildCSGRResultData(vo)
|
|
self.guild_csgr_result_data = vo
|
|
end
|
|
function GuildModel:GetGuildCSGRResultData( )
|
|
return self.guild_csgr_result_data
|
|
end
|
|
-- 本国团战相关协议 end
|
|
--------- 社团协议相关代码 end ---------
|
|
|
|
--------- 社团红点提醒相关代码 start ---------
|
|
-- 设置社团申请的状态 11016
|
|
function GuildModel:SetApplyRedPointState(apply_pos)
|
|
-- 通过这个标志量可以不请求社团申请信息直接展示社团申请的红点
|
|
self.member_refresh_check = true
|
|
if apply_pos == 0 then
|
|
if not self.member_apply_red then
|
|
self:Fire(GuildModel.REQUEST_CCMD_EVENT, 40008) -- 请求申请列表
|
|
end
|
|
else
|
|
if not self.pos_apply_red and self:HasAppointPremission(apply_pos) then
|
|
self:Fire(GuildModel.REQUEST_CCMD_EVENT, 40008) -- 请求申请列表
|
|
end
|
|
end
|
|
end
|
|
-- 2020年1月10日修改：统一红点的规则框架，只需要加载两次，数据不更新的情况下获取缓存即可
|
|
function GuildModel:CheckGuildRedDotAll( )
|
|
-- 社团的红点一律需要判断是否加入了社团
|
|
local joined_guild = RoleManager.Instance.mainRoleInfo.guild_id ~= 0
|
|
self.guild_red_cache[Config.ConfigGuild.TabId.MainInfo] = joined_guild and self:CheckGuildInfoRedDot()
|
|
self.guild_red_cache[Config.ConfigGuild.TabId.List] = joined_guild and self:CheckGuildListRedDot()
|
|
self.guild_red_cache[Config.ConfigGuild.TabId.Active] = joined_guild and self:CheckGuildActiveRed()
|
|
self.guild_red_cache[Config.ConfigGuild.TabId.Order] = joined_guild and self:CheckGuildOrderRed()
|
|
self.guild_red_cache[Config.ConfigGuild.TabId.Shop] = joined_guild and self:CheckGuildShopRed()
|
|
-- self.guild_red_cache[Config.ConfigGuild.TabId.Event] = joined_guild and self:CheckGuildEventRed()
|
|
self.guild_red_cache[Config.ConfigGuild.TabId.Event] = false
|
|
self:CheckGuildMainIconRed()
|
|
end
|
|
-- 获取社团红点缓存
|
|
function GuildModel:GetGuildRedDotCache( view_type )
|
|
return not view_type and self.guild_red_cache or self.guild_red_cache[view_type]
|
|
end
|
|
|
|
-- 检查社团模块红点 view_type:界面类型
|
|
function GuildModel:CheckGuildRedDot(view_type, is_all)
|
|
local bool = false
|
|
if view_type == Config.ConfigGuild.TabId.MainInfo then -- 社团主界面信息页签
|
|
bool = self:CheckGuildInfoRedDot()
|
|
elseif view_type == Config.ConfigGuild.TabId.List then -- 社团列表页签
|
|
bool = self:CheckGuildListRedDot()
|
|
elseif view_type == Config.ConfigGuild.TabId.Active then -- 社团活跃页签
|
|
bool = self:CheckGuildActiveRed()
|
|
elseif view_type == Config.ConfigGuild.TabId.Order then -- 社团拼单页签
|
|
bool = self:CheckGuildOrderRed()
|
|
elseif view_type == Config.ConfigGuild.TabId.Shop then -- 社团商店页签
|
|
bool = self:CheckGuildShopRed()
|
|
elseif view_type == Config.ConfigGuild.TabId.Event then -- 社团活动页签
|
|
-- bool = self:CheckGuildEventRed()
|
|
self:CheckGuildEventRed() --检测红点 但不使用红点，检测红点只给活动页签"进行中"标志使用
|
|
bool = false
|
|
end
|
|
-- 社团的红点一律需要判断是否加入了社团
|
|
local guild_id = RoleManager.Instance.mainRoleInfo.guild_id
|
|
self.guild_red_cache[view_type] = bool and guild_id ~= 0
|
|
self:Fire(GuildModel.UPDATE_RED_DOT_BY_TYPE, view_type)
|
|
if is_all then
|
|
self:CheckGuildMainIconRed()
|
|
end
|
|
return bool
|
|
end
|
|
|
|
function GuildModel:CheckGuildMainIconRed( )
|
|
local show = false
|
|
for k,v in pairs(self.guild_red_cache) do
|
|
if v == true then
|
|
show = v
|
|
break
|
|
end
|
|
end
|
|
GlobalEventSystem:Fire(EventName.SHOW_FUNCTION_RED_POINT, 400, show) --通知自己功能按钮红点
|
|
end
|
|
|
|
--检查主页信息红点
|
|
function GuildModel:CheckGuildInfoRedDot()
|
|
local red_packet_red = RedPacketModel:GetInstance():GetGuildRedPacketRed()
|
|
local merge_tip_red = self:CheckGuildMergeTipRed()
|
|
return red_packet_red or merge_tip_red
|
|
end
|
|
-- 检查社团低活跃情况时的合并提示
|
|
function GuildModel:CheckGuildMergeTipRed( )
|
|
self.merge_tip_red = false
|
|
if self:HasOperatePermission(GuildModel.MgrPermission.MergeGuild) then -- 有合并权限的玩家才可以显示红点
|
|
local cookie_warpper = CookieWrapper.Instance
|
|
local next_tip_time = cookie_warpper:GetCookie(CookieLevelType.Account, CookieKey.GUILD_NEXT_MERGE_TIP_TIME)
|
|
local cur_time = TimeUtil:getServerTime()
|
|
if not next_tip_time or next_tip_time < cur_time then
|
|
-- 如果需要更新缓存，就代表玩家查看过合并界面，到下一个时间段之前都不会处理合并提示的红点
|
|
if self.save_merge_cache_time then
|
|
local cur_time_data = os.date("*t", cur_time)
|
|
cur_time_data.hour = 0
|
|
cur_time_data.min = 0
|
|
cur_time_data.sec = 0
|
|
-- 低活跃刷新的时间分别时周一和周五，需要推算今日零点距离下一次低活跃刷新的秒数时间缓存起来
|
|
local cur_wday = cur_time_data.wday - 1 -- 值域1~7，周日是1，-1做正常映射，周日特殊处理
|
|
local off_wday
|
|
if cur_time_data.wday >= 1 and cur_wday < 5 then -- 以周五为节点
|
|
off_wday = 5 - cur_wday
|
|
else -- 以下周一为节点
|
|
off_wday = 1 - cur_wday + (cur_wday > 0 and 7 or 0)
|
|
end
|
|
local today_0_clock = os.time(cur_time_data)
|
|
next_tip_time = today_0_clock + off_wday * 86400 - 1
|
|
cookie_warpper:SaveCookie(CookieLevelType.Account, CookieTimeType.TYPE_ALWAYS, CookieKey.GUILD_NEXT_MERGE_TIP_TIME, next_tip_time)
|
|
cookie_warpper:WriteAll()
|
|
else -- 不更新时间缓存以及到了下一个结算时间段的情况，就刷新红点状态
|
|
local merge_condition = self:GetGuildMergeConditionCfg()
|
|
if merge_condition and merge_condition.open == 1 then
|
|
local basic_info = self:GetGuildBaseInfo()
|
|
local guild_division = basic_info and basic_info.division or 0
|
|
local division_lv_list = stringtotable(merge_condition.merge_lv)
|
|
local can_merge = false
|
|
for k,v in pairs(division_lv_list) do
|
|
if v == guild_division then
|
|
can_merge = true
|
|
end
|
|
end
|
|
self.merge_tip_red = can_merge
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return self.merge_tip_red
|
|
end
|
|
function GuildModel:GetGuildMergeTipRed( )
|
|
return self.merge_tip_red
|
|
end
|
|
function GuildModel:SetGuildSaveMergeCacheTimeFlag(bool)
|
|
local need_refresh = self.save_merge_cache_time ~= bool
|
|
self.save_merge_cache_time = bool
|
|
if need_refresh then -- 状态变化，刷新红点
|
|
self:CheckGuildRedDot(Config.ConfigGuild.TabId.MainInfo, true)
|
|
end
|
|
end
|
|
-- 检查列表页签红点
|
|
function GuildModel:CheckGuildListRedDot( )
|
|
local bool = self:CheckGuildListApplyRed()
|
|
return bool
|
|
end
|
|
-- 获取社团人员管理红点
|
|
function GuildModel:CheckGuildListApplyRed( )
|
|
-- 社团申请的红点需要管理才可以操作
|
|
-- 入团申请红点,需要拥有审批入会权限
|
|
self.member_apply_red = #self.apply_guild_list > 0
|
|
and self:HasOperatePermission(GuildModel.MgrPermission.PassJoinApply) or false
|
|
|
|
-- 职位申请红点,需要逐个判断
|
|
self.pos_apply_red = false
|
|
for k, v in ipairs(self.apply_pos_list) do
|
|
if self:HasAppointPremission(v.position) then
|
|
self.pos_apply_red = true
|
|
break
|
|
end
|
|
end
|
|
|
|
-- 社团合并红点
|
|
self.member_merge_red = self.guild_merge_info and #self.guild_merge_info.fapplys > 0
|
|
and self:HasOperatePermission(GuildModel.MgrPermission.MergeGuild) or false -- 接收方才需要红点
|
|
|
|
-- 申请入团和职位以及合并请求的红点，在关闭申请管理界面后消除
|
|
return (self.member_apply_red or self.pos_apply_red or self.member_merge_red) and self.member_refresh_check
|
|
end
|
|
-- 获取入团申请，职位申请和合并申请按钮的红点
|
|
function GuildModel:GetGuildMemberApplyRed( )
|
|
return self.member_apply_red
|
|
end
|
|
function GuildModel:GetGuildPosApplyRed( )
|
|
return self.pos_apply_red
|
|
end
|
|
function GuildModel:GetGuildMemberMergeRed( )
|
|
return self.member_merge_red
|
|
end
|
|
function GuildModel:CheckMemberRedDot( )
|
|
if self.member_refresh_check then
|
|
self.member_refresh_check = false
|
|
self:CheckGuildRedDot(Config.ConfigGuild.TabId.List, true)
|
|
end
|
|
end
|
|
|
|
-- 获取社团活跃红点
|
|
function GuildModel:CheckGuildActiveRed()
|
|
local bool = self:GetGuildActiveProgressRed()
|
|
bool = bool or self:CheckGuildActiveTaskRed()
|
|
return bool
|
|
end
|
|
|
|
-- 获取社团活跃社团进度奖励红点
|
|
function GuildModel:GetGuildActiveProgressRed(id)
|
|
-- 若个人活跃没有达到阈值则直接false
|
|
local p_active_require = self:GetGuildKvByKey("min_active_require").val
|
|
if p_active_require > self.personal_active then return false end
|
|
-- 获取活跃配置以及当前相应的活跃值和活跃阶段
|
|
local act_cfg = self:GetActiveRewardCfg()
|
|
local bool = false
|
|
for k, v in ipairs(act_cfg) do
|
|
if v.id == self.guild_active_stage + 1 and self.guild_active >= v.need then -- 当前阶段是已领取阶段的下一阶段，且超过了该阶段需要的活跃值
|
|
bool = id == nil or v.id == id
|
|
break
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
-- 获取社团活跃任务红点
|
|
function GuildModel:CheckGuildActiveTaskRed( )
|
|
-- 获取玩家当前活跃任务的领取情况
|
|
local bool = false
|
|
local active_task_progress = self:GetGuildActiveTaskData()
|
|
for k, v in pairs(active_task_progress) do
|
|
if v.state == 1 then -- 可领取
|
|
bool = true
|
|
break
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
-- 获取社团拼单页签红点
|
|
function GuildModel:CheckGuildOrderRed( )
|
|
-- 暂时屏蔽次数红点
|
|
if not self.guild_order_login_red then return false end
|
|
local sl_data = self:GetGuildSpellListData()
|
|
local total_num = self:GetGuildKvByKey("accept_limit").val
|
|
-- 有剩余次数就给红点
|
|
if sl_data and total_num - sl_data.ordered > 0 then
|
|
return true
|
|
else
|
|
-- 没有拼单的红点的话，登录红点也不需要存在了
|
|
self.guild_order_login_red = false
|
|
return false
|
|
end
|
|
-- return self.guild_order_login_red and sl_data and total_num - sl_data.ordered > 0 or false
|
|
end
|
|
|
|
-- 检查商店红点
|
|
function GuildModel:CheckGuildShopRed( )
|
|
local guild_coin = RoleManager.Instance.mainRoleInfo.guild_contribute
|
|
local coin_threashold = self:GetGuildKvByKey("store_reddot").val
|
|
local goods_list = self:GetGuildShopGoodsList()
|
|
-- 判断当前是否有龙神券可购买
|
|
self.guild_shop_special_item_red = {}
|
|
local can_buy_capsule_ticket = false
|
|
local can_buy_goods = false -- 存在可购买的道具
|
|
if goods_list and TableSize(goods_list) > 0 then
|
|
for k, v in pairs(goods_list) do
|
|
if v.id == 1 then -- 龙神单抽券
|
|
if v.can_buy then -- 可以购买
|
|
local cost_cfg = stringtotable(v.cost)[1]
|
|
can_buy_capsule_ticket = cost_cfg[3] <= guild_coin
|
|
self.guild_shop_special_item_red[v.id] = can_buy_capsule_ticket
|
|
end
|
|
-- break
|
|
can_buy_goods = can_buy_goods or v.can_buy
|
|
end
|
|
end
|
|
end
|
|
-- 当存在龙神单抽券可购买 或 社团货币超过提示的值且允许显示超过值的阈值 则 给红点
|
|
return can_buy_capsule_ticket or ((guild_coin >= coin_threashold) and can_buy_goods and self.show_guild_shop_red) or false
|
|
end
|
|
|
|
function GuildModel:GetGuildShopSpecialItemRedById(id)
|
|
return self.guild_shop_special_item_red[id] or false
|
|
end
|
|
|
|
-- 检查社团活动红点
|
|
function GuildModel:CheckGuildEventRed( )
|
|
local bool = false
|
|
for k, v in pairs(self.guild_event_tab_red) do
|
|
bool = v or bool
|
|
end
|
|
return bool
|
|
end
|
|
function GuildModel:GetGuildEventTabRed(type)
|
|
return type and self.guild_event_tab_red[type] or false
|
|
end
|
|
--------- 社团红点提醒相关代码 end ---------
|
|
|
|
--------- 社团数据获取相关代码 start ---------
|
|
-- 获取社团信息界面用的社团成员信息
|
|
function GuildModel:GetGuildMemberListForInfoView( )
|
|
local tb = {}
|
|
local role_id = RoleManager.Instance.mainRoleInfo.role_id
|
|
local role_data = nil
|
|
for k, v in pairs(self.member_list) do
|
|
-- 筛选出玩家数据
|
|
if v.role_id ~= role_id then
|
|
tb[#tb+1] = v
|
|
else
|
|
role_data = v
|
|
end
|
|
end
|
|
local sort_func = function ( a, b )
|
|
if a.online_flag ~= b.online_flag then
|
|
-- if a.online_flag == 1 then -- 在线置顶
|
|
-- return true
|
|
-- elseif b.online_flag == 1 then
|
|
-- return false
|
|
-- else
|
|
return a.online_flag > b.online_flag
|
|
-- end
|
|
else
|
|
return a.power > b.power
|
|
end
|
|
end
|
|
table.sort(tb, sort_func)
|
|
-- 玩家数据前置
|
|
if role_data then
|
|
table.insert(tb, 1, role_data)
|
|
end
|
|
return tb
|
|
end
|
|
|
|
-- 获取社团信息界面用的社团成员信息
|
|
-- s_type : 特殊类型 不传则什么也不做 1 社团拼单邀请，需要加一个假人数据
|
|
function GuildModel:GetGuildMemberListForInviteView(s_type)
|
|
local tb = {}
|
|
local role_id = RoleManager.Instance.mainRoleInfo.role_id
|
|
for k, v in pairs(self.member_list) do
|
|
-- 筛选出玩家数据
|
|
if v.role_id ~= role_id then
|
|
tb[#tb+1] = v
|
|
end
|
|
end
|
|
local sort_func = function ( a, b )
|
|
if a.online_flag ~= b.online_flag then
|
|
return a.online_flag > b.online_flag
|
|
else
|
|
return a.power > b.power
|
|
end
|
|
end
|
|
table.sort(tb, sort_func)
|
|
if s_type then
|
|
if s_type == 1 then -- 社团拼单添加假人
|
|
local has_inserted = false
|
|
local fake_role = {
|
|
role_id = 1,
|
|
vip_flag = 0,
|
|
sup_vip_type = 0,
|
|
name = "社团助手",
|
|
}
|
|
for k, v in ipairs(tb) do
|
|
if v.online_flag == 0 then -- 检查到这个位置是离线玩家，则插入数据
|
|
table.insert(tb, k, fake_role)
|
|
has_inserted = true
|
|
break
|
|
end
|
|
end
|
|
if not has_inserted then -- 如果上面没有插入社团ai数据，则在这边补充
|
|
table.insert(tb, fake_role)
|
|
end
|
|
end
|
|
end
|
|
return tb
|
|
end
|
|
|
|
-- 获取对应职位的玩家信息
|
|
function GuildModel:GetMemberDataByPosition(position)
|
|
local tb = {}
|
|
for k, v in pairs(self.member_list) do
|
|
if v.position == position then
|
|
tb[#tb+1] = v
|
|
end
|
|
end
|
|
return tb
|
|
end
|
|
-- 踢出玩家后，前端自行处理本地社团成员缓存
|
|
function GuildModel:UpdateMemberAfterKick(kick_id)
|
|
for k, v in pairs(self.member_list) do
|
|
if v.role_id == kick_id then
|
|
table.remove(self.member_list, k)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 根据社团等级获取对应特殊职位的人数
|
|
function GuildModel:GetPositionNum( position )
|
|
if not position then return 0 end
|
|
if position == GuildModel.GuildPosition.Agency then return 1 end
|
|
local guild_lv = self.base_info.guild_lv or 1
|
|
for k, cfg in pairs(Config.Guildlv) do
|
|
if cfg.lv == guild_lv then
|
|
local pos_list = stringtotable(cfg.pos_list)
|
|
for k2, pos_data in pairs(pos_list) do
|
|
if pos_data[1] == position then
|
|
return pos_data[2]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return 0
|
|
end
|
|
|
|
-- 根据目标职位获取申请人列表
|
|
function GuildModel:GetPositionApplyList(position)
|
|
local tb = {}
|
|
if position then
|
|
for k, v in ipairs(self.apply_member_list) do
|
|
if v.position == position then
|
|
tb[#tb+1] = v
|
|
end
|
|
end
|
|
end
|
|
return tb
|
|
end
|
|
|
|
--创建花火大会客户端怪物
|
|
function GuildModel:CreateGuildPartyMonster( )
|
|
if not self.feast_monster_vo then
|
|
self.feast_monster_vo = MonsterVo.New()
|
|
self.feast_monster_vo.instance_id = GuildModel.FEAST_MONSTER_INSTANCE_ID
|
|
self.feast_monster_vo.type_id = self:GetGuildKvByKey("ballroom").val
|
|
|
|
local cfg_data = ConfigItemMgr.Instance:GetMonsterDataItem(self.feast_monster_vo.type_id)
|
|
if cfg_data then
|
|
self.feast_monster_vo.monster_res = cfg_data.icon
|
|
self.feast_monster_vo.name = cfg_data.name
|
|
self.feast_monster_vo.type = 0
|
|
self.feast_monster_vo.move_speed = cfg_data.speed
|
|
self.feast_monster_vo.icon_scale = 5--tonumber(cfg_data.icon_scale)
|
|
end
|
|
|
|
self.feast_monster_vo:SetBasePropertyFromConfig()
|
|
local mon_pos = stringtotable(self:GetGuildKvByKey("ballroom_position").val)[1]
|
|
self.feast_monster_vo.pos_x = mon_pos[1]
|
|
self.feast_monster_vo.pos_y = mon_pos[2]
|
|
|
|
|
|
if self.feast_monster_vo.monster_res == 0 then
|
|
return --暂时没处理
|
|
end
|
|
|
|
self.feast_monster_vo.level = 1
|
|
self.feast_monster_vo.hp=1
|
|
self.feast_monster_vo.mp=1
|
|
self.feast_monster_vo.maxHp=1
|
|
self.feast_monster_vo.maxMp=1
|
|
self.feast_monster_vo.guaji_flag = 1
|
|
self.feast_monster_vo.hide_flag = false
|
|
self.feast_monster_vo.can_attack = 0
|
|
self.feast_monster_vo.can_pick = 0
|
|
self.feast_monster_vo.is_hide_nameboard = true
|
|
self.feast_monster_vo.is_client_monster = true --是否是客户端怪物
|
|
self.feast_monster_vo.client_default_action = "close"
|
|
local info = self.feast_info
|
|
if info and info.status == 1 then
|
|
self.feast_monster_vo.client_default_action = "open"
|
|
self.feast_monster_vo.client_default_speed = 0.3
|
|
end
|
|
SceneManager.Instance:AddMonsterVo(self.feast_monster_vo, false)
|
|
end
|
|
end
|
|
function GuildModel:DeleteGuildPartyMonster( )
|
|
self.feast_monster_vo = nil
|
|
SceneManager.Instance:DeleteClientMonstersByInstanceId(GuildModel.FEAST_MONSTER_INSTANCE_ID)
|
|
end
|
|
|
|
-- 根据目标职位和战力及活跃条件获取社团成员列表（社团职位分配界面用）
|
|
-- sort_type 12战力排序规则:1降序 2升序 34活跃排序规则:3降序 4升序
|
|
function GuildModel:GetMemDataByPosAndSortCondition(pos, sort_type)
|
|
local mem_list = DeepCopy(self:GetGuildMemberList())
|
|
-- 缓存各种排序规则
|
|
local sort_func_list = {
|
|
[1] = function (a, b)
|
|
return a.power > b.power
|
|
end,
|
|
[2] = function (a, b)
|
|
return a.power < b.power
|
|
end,
|
|
[3] = function (a, b)
|
|
return a.total_labor > b.total_labor
|
|
end,
|
|
[4] = function (a, b)
|
|
return a.total_labor < b.total_labor
|
|
end,
|
|
}
|
|
local type_func = sort_func_list[sort_type]
|
|
local sort_func = function ( a, b )
|
|
if a.position == pos and b.position ~= pos then
|
|
return true
|
|
elseif a.position ~= pos and b.position == pos then
|
|
return false
|
|
else
|
|
return type_func(a, b)
|
|
end
|
|
end
|
|
table.sort(mem_list, sort_func)
|
|
return mem_list
|
|
end
|
|
|
|
-- 根据玩家的离线情况和战斗力排序 type:1战力降序 2战力升序 3在线在前战力降序 4离线在前战力降
|
|
function GuildModel:GetMemDataByOnlineAndPower(type)
|
|
local mem_list = DeepCopy(self:GetGuildMemberList())
|
|
-- 缓存各种排序规则
|
|
local sort_func_list = {
|
|
[1] = function (a, b)
|
|
return a.power > b.power
|
|
end,
|
|
[2] = function (a, b)
|
|
return a.power < b.power
|
|
end,
|
|
[3] = function (a, b)
|
|
if a.online_flag ~= b.online_flag then
|
|
return a.online_flag == 1
|
|
-- if a.online_flag == 1 then -- 在线置顶
|
|
-- return true
|
|
-- elseif b.online_flag == 1 then
|
|
-- return false
|
|
-- else
|
|
-- return a.online_flag > b.online_flag
|
|
-- end
|
|
else
|
|
return a.power > b.power
|
|
end
|
|
end,
|
|
[4] = function (a, b)
|
|
if a.online_flag ~= b.online_flag then
|
|
return a.online_flag == 0
|
|
-- if a.online_flag == 0 then -- 在线置顶
|
|
-- return true
|
|
-- elseif b.online_flag == 0 then
|
|
-- return false
|
|
-- else
|
|
-- return a.online_flag > b.online_flag
|
|
-- end
|
|
else
|
|
return a.power > b.power
|
|
end
|
|
end,
|
|
}
|
|
local type_func = sort_func_list[type]
|
|
local sort_func = function ( a, b )
|
|
return type_func(a, b)
|
|
end
|
|
table.sort(mem_list, sort_func)
|
|
return mem_list
|
|
end
|
|
|
|
--获得社团支持名字
|
|
function GuildModel:GetSupportTypeName( boss_type )
|
|
if boss_type == Config.ConfigBoss.ModuleId.World then
|
|
return "世界BOSS"
|
|
elseif boss_type == Config.ConfigBoss.ModuleId.Money then
|
|
return "赏金幻魔"
|
|
elseif boss_type == Config.ConfigBoss.ModuleId.Person then
|
|
return "专属幻魔"
|
|
elseif boss_type == Config.ConfigBoss.ModuleId.Collect then
|
|
return "裂隙首领"
|
|
elseif boss_type == Config.ConfigBoss.ModuleId.Deserted then
|
|
return "星域幻魔"
|
|
end
|
|
end
|
|
|
|
function GuildModel:CancelCollectSupport()--取消采集协助
|
|
local support_status = self:GetGuildSupportStatus( )--离开社团驻地时且是协助他人 取消协助
|
|
if support_status == 1 or support_status == 2 then
|
|
self:Fire(GuildModel.REQUEST_CCMD_EVENT, 40053)
|
|
end
|
|
end
|
|
|
|
-- 发布社团招募
|
|
function GuildModel:SendRecruitMsg( )
|
|
local vo = self:GetGuildBaseInfo()
|
|
if not vo then
|
|
return
|
|
end
|
|
local guild_lv_cfg = Config.Guildlv[vo.guild_lv]
|
|
if vo.member_num >= (guild_lv_cfg.member_capacity + GuildModel:getInstance():GetAddMemNum()) then
|
|
Message.show("社团成员已满，无需招募")
|
|
else
|
|
if Status.NowTime - self.last_recruit_time > 30 then
|
|
local content = string.format("<color=#d322ff>【%s】</color>社团招贤纳士，欢迎各界人士加入！<color=#2cf89a><a@guild_rec@%s>[我要申请]</color></a>"
|
|
,vo.guild_name,vo.guild_id)
|
|
ChatModel:getInstance():Fire(ChatModel.SEND_MSG, ChatModel.CHANNEL_WORLD, content, 0, nil, ChatModel.CHAT_COMMON_TYPE.SYSTEM)
|
|
self.last_recruit_time = Status.NowTime
|
|
Message.show("发布招募信息成功", "success")
|
|
else
|
|
Message.show("嗓子喊累了，休息下吧~", "fault")
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 发布社团频道传闻信息 msg:信息内容 cd:信息的冷却时间(默认10秒) tips:发送成功后飘字
|
|
function GuildModel:SendGuildChuanwenMsg(msg, tips, cd)
|
|
if not msg or msg == "" then return end
|
|
local vo = self:GetGuildBaseInfo()
|
|
if not vo then
|
|
return
|
|
end
|
|
cd = cd or 10
|
|
if Status.NowTime - self.last_send_chuanwen_time > cd then -- 处于冷却时间内才可以发
|
|
ChatModel:getInstance():Fire(ChatModel.SEND_MSG, ChatModel.CHANNEL_GUILD, msg, 0, nil, ChatModel.CHAT_COMMON_TYPE.SYSTEM)
|
|
self.last_send_chuanwen_time = Status.NowTime
|
|
Message.show(tips or "发布信息成功", "succeed")
|
|
else
|
|
Message.show("嗓子喊累了，休息下吧~", "fault")
|
|
end
|
|
end
|
|
|
|
--社团boss击杀后300的秒内执行特殊拾取逻辑
|
|
function GuildModel:GetSepcialPickLogicOfGBoss()
|
|
if not SceneManager:getInstance():IsGuildScene() then return false end
|
|
local noon_boss_data = self:GetGuildEventByType(GuildEventType.GuildBossNoon)
|
|
if noon_boss_data and noon_boss_data.state == 1 then
|
|
return true
|
|
end
|
|
local night_boss_data = self:GetGuildEventByType(GuildEventType.GuildBossNight)
|
|
if night_boss_data and night_boss_data.state == 1 then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
--------------------------本服团战相关 开始--------------------------
|
|
|
|
--上期明星团长
|
|
function GuildModel:GuildWarSetLastMvp(mvp)
|
|
self.guild_war_info.last_mvp = mvp
|
|
self:Fire(GuildModel.GUILD_WAR_LAST_MVP)
|
|
end
|
|
|
|
--排行数据
|
|
function GuildModel:GuildWarSetRankList(list, i_type)
|
|
--清空数据
|
|
if not list then
|
|
self.guild_war_info = self.guild_war_info or {}
|
|
self.guild_war_info.rank_list = {}
|
|
self.guild_war_info.my_rank_info = {}
|
|
return
|
|
end
|
|
self.guild_war_info.rank_list = self.guild_war_info.rank_list or {}
|
|
self.guild_war_info.my_rank_info = self.guild_war_info.my_rank_info or {}
|
|
|
|
list = list or {}
|
|
if #list >= 2 then
|
|
table.sort(list, function (a, b)
|
|
if a.score ~= b.score then
|
|
return a.score > b.score
|
|
else
|
|
return a.time < b.time
|
|
end
|
|
end)
|
|
end
|
|
|
|
local my_info = {}
|
|
|
|
|
|
if i_type == GuildWarRankView.TAB_ID.PERSON then
|
|
local my_kill_info = {}
|
|
local kill_list_temp = DeepCopy(list)
|
|
local role_name = RoleManager.Instance:GetMainRoleName()
|
|
for i,v in ipairs(list) do
|
|
if v.name == role_name then
|
|
my_info = v
|
|
my_info.my_rank = i
|
|
my_info.score = v.score
|
|
my_info.name = v.name
|
|
my_kill_info = DeepCopy(v)
|
|
end
|
|
v.value_1 = ""
|
|
v.value_2 = v.score
|
|
end
|
|
|
|
local kill_list = {}
|
|
for i,v in ipairs(kill_list_temp) do
|
|
if v.max_kill > 0 then
|
|
table.insert(kill_list, v)
|
|
end
|
|
end
|
|
if #kill_list >= 2 then
|
|
table.sort(kill_list, function (a, b)
|
|
if a.max_kill ~= b.max_kill then
|
|
return a.max_kill > b.max_kill
|
|
else
|
|
return a.continue_kill > b.continue_kill
|
|
end
|
|
end)
|
|
end
|
|
my_kill_info.my_rank = 0
|
|
my_kill_info.max_kill = 0
|
|
my_kill_info.continue_kill = 0
|
|
my_kill_info.value_1 = ""
|
|
my_kill_info.value_2 = string.format("%d击杀%d连斩", 0, 0)
|
|
for i,v in ipairs(kill_list) do
|
|
if v.name == role_name then
|
|
my_kill_info = v
|
|
my_kill_info.my_rank = i
|
|
my_kill_info.max_kill = v.max_kill
|
|
my_kill_info.continue_kill = v.continue_kill
|
|
end
|
|
v.value_1 = ""
|
|
v.value_2 = string.format("%d击杀%d连斩", v.max_kill, v.continue_kill)
|
|
end
|
|
|
|
--击杀榜
|
|
self.guild_war_info.rank_list[3] = kill_list
|
|
self.guild_war_info.my_rank_info[3] = my_kill_info
|
|
|
|
else
|
|
local guild_id = self.base_info.guild_id
|
|
for i,v in ipairs(list) do
|
|
if v.guild_id == guild_id then
|
|
my_info.my_rank = i
|
|
my_info.score = v.score
|
|
my_info.name = v.name
|
|
my_info.value_1 = v.guild_name
|
|
my_info.value_2 = v.score
|
|
end
|
|
v.value_1 = v.guild_name
|
|
v.value_2 = v.score
|
|
end
|
|
end
|
|
|
|
self.guild_war_info.rank_list[i_type] = list
|
|
self.guild_war_info.my_rank_info[i_type] = my_info
|
|
self:Fire(GuildModel.GUILD_WAR_RANK_LIST, i_type)
|
|
end
|
|
|
|
function GuildModel:GuideWarSetPickState(pick_id)
|
|
self.guild_war_info.pick_id = pick_id
|
|
if pick_id ~= 0 then
|
|
self:FindGuideWarTarget(GuildModel.GuildWarTarget.Npc)
|
|
self.guild_war_info.last_pick_id = nil
|
|
end
|
|
self:Fire(GuildModel.GUILD_WAR_PICK_STATE, pick_id)
|
|
end
|
|
|
|
function GuildModel:GuideWarGiveInPick(npc_id)
|
|
if SceneManager:getInstance():IsGuildWarScene() and self:IsGuildWarNpcId(npc_id) then
|
|
--对话确认后，如果有粮食，就去交粮食，没有粮食去找粗粮，
|
|
if self.guild_war_info.pick_id and self.guild_war_info.pick_id ~= 0 then
|
|
self:Fire(GuildModel.REQUEST_CCMD_EVENT,40507, npc_id)
|
|
self.guild_war_info.last_pick_id = self.guild_war_info.pick_id
|
|
else
|
|
self:FindGuideWarTarget(GuildModel.GuildWarTarget.SmallRice)
|
|
end
|
|
end
|
|
end
|
|
|
|
function GuildModel:IsGuideWarPickTypeId(type_id)
|
|
return type_id == GuildModel.GuildWarTarget.SmallRice or type_id == GuildModel.GuildWarTarget.MiddleRice or type_id == GuildModel.GuildWarTarget.BigRice
|
|
end
|
|
|
|
function GuildModel:GuideWarGiveInPickResult()
|
|
--提交之后，自动找粗粮
|
|
self.guild_war_info.last_pick_id = nil
|
|
self:FindGuideWarTarget(GuildModel.GuildWarTarget.SmallRice)
|
|
end
|
|
|
|
function GuildModel:GetRankData(i_type)
|
|
local t1 = self.guild_war_info.rank_list
|
|
local t2 = self.guild_war_info.my_rank_info
|
|
return t1 and t1[i_type] or {}, t2 and t2[i_type] or {}
|
|
end
|
|
|
|
--大战状态信息
|
|
function GuildModel:GuildWarSetInfo(begin_time, end_time, score, max_pool)
|
|
self.guild_war_info.begin_time = begin_time
|
|
self.guild_war_info.end_time = end_time
|
|
self.guild_war_info.score = score
|
|
self.guild_war_info.max_pool = max_pool
|
|
self:Fire(GuildModel.GUILD_WAR_BASE_INFO)
|
|
end
|
|
|
|
--大战状态信息
|
|
function GuildModel:GuildWarProject(cd_time)
|
|
self.guild_war_info = self.guild_war_info or {}
|
|
self.guild_war_info.cd_time = cd_time
|
|
self:Fire(GuildModel.GUILD_WAR_PROJECT)
|
|
end
|
|
|
|
--大战 积分更新
|
|
function GuildModel:GuildWarSetScore(score)
|
|
self.guild_war_info.score = score
|
|
self:Fire(GuildModel.GUILD_WAR_UPDATE_SCROE, score)
|
|
end
|
|
|
|
--大战 积分更新
|
|
function GuildModel:GuildWarSetResult(top_guild, top_guild_chief, my_guild_rank, my_personal_rank, score, kill_rank)
|
|
self.guild_war_info.result = {}
|
|
self.guild_war_info.result.mvp_guild = top_guild
|
|
self.guild_war_info.result.mvp_leader = top_guild_chief
|
|
self.guild_war_info.result.my_guild_rank = my_guild_rank
|
|
self.guild_war_info.result.my_rank = my_personal_rank
|
|
self.guild_war_info.result.my_score = score
|
|
self.guild_war_info.result.kill_rank = kill_rank
|
|
if SceneManager:getInstance():IsGuildWarScene() then
|
|
GlobalEventSystem:Fire(EventName.STOPAUTOFIGHT, false, true)
|
|
else
|
|
self:Fire(GuildModel.GUILD_WAR_RESULT)
|
|
end
|
|
end
|
|
|
|
--大战寻找目标
|
|
function GuildModel:FindGuideWarTarget(i_type)
|
|
if not SceneManager:getInstance():IsGuildWarScene() then
|
|
Message.show("当前不在活动场景中")
|
|
end
|
|
|
|
--如果当前有采集物，继续点采集，则直接去交任务
|
|
if self.guild_war_info.pick_id and self.guild_war_info.pick_id ~= 0 and (i_type == GuildModel.GuildWarTarget.SmallRice or i_type == GuildModel.GuildWarTarget.MiddleRice or i_type == GuildModel.GuildWarTarget.BigRice) then
|
|
i_type = GuildModel.GuildWarTarget.Npc
|
|
end
|
|
|
|
local target_id = false
|
|
local scene_id = 4100
|
|
local list = SceneManager.Instance.monster_vo_list
|
|
if i_type == GuildModel.GuildWarTarget.Boss then
|
|
target_id = GuildModel.GuildWarTarget.Boss
|
|
elseif i_type == GuildModel.GuildWarTarget.SmallRice then
|
|
target_id = GuildModel.GuildWarTarget.SmallRice
|
|
elseif i_type == GuildModel.GuildWarTarget.MiddleRice then
|
|
target_id = GuildModel.GuildWarTarget.MiddleRice
|
|
elseif i_type == GuildModel.GuildWarTarget.BigRice then
|
|
target_id = GuildModel.GuildWarTarget.BigRice
|
|
elseif i_type == GuildModel.GuildWarTarget.Npc then
|
|
list = SceneManager.Instance.npc_vo_list
|
|
target_id = GuildModel.GuildWarTarget.Npc
|
|
end
|
|
|
|
local vo = false
|
|
local vo_list = {}
|
|
local is_npc = target_id == GuildModel.GuildWarTarget.Npc
|
|
for k,v in pairs(list) do
|
|
if (v.type_id == target_id) or (is_npc and ( v.type_id == GuildModel.GuildWarTarget.Npc_1 or v.type_id == GuildModel.GuildWarTarget.Npc_2 or v.type_id == GuildModel.GuildWarTarget.Npc_3 )) then
|
|
table.insert(vo_list, v)
|
|
end
|
|
end
|
|
|
|
if #vo_list > 0 then
|
|
--npc 取最近的一个，粮食随机.bpss，就只有一个
|
|
if is_npc then
|
|
vo = vo_list[1]
|
|
local GameMath_GetDistance = GameMath.GetDistance
|
|
local lx, ly = Scene.Instance.main_role:GetLogicPos()
|
|
local dis = GameMath_GetDistance(lx, ly, vo.pos_x / SceneObj.LogicRealRatio.x, vo.pos_y / SceneObj.LogicRealRatio.y)
|
|
for i,v in ipairs(vo_list) do
|
|
if vo.type_id ~= v.type_id then
|
|
local temp_dis = GameMath_GetDistance(lx, ly, v.pos_x / SceneObj.LogicRealRatio.x, v.pos_y / SceneObj.LogicRealRatio.y)
|
|
if temp_dis < dis then
|
|
vo = v
|
|
dis = temp_dis
|
|
end
|
|
end
|
|
end
|
|
else
|
|
if #vo_list == 1 then
|
|
vo = vo_list[1]
|
|
else
|
|
local idx = math.random(1,#vo_list)
|
|
vo = vo_list[idx]
|
|
end
|
|
end
|
|
end
|
|
|
|
if target_id and vo then
|
|
local findVo = FindVo.New()
|
|
findVo.type = is_npc and FindVo.NPC or FindVo.MONSTER
|
|
findVo.id = vo.type_id
|
|
findVo.x = vo.pos_x / SceneObj.LogicRealRatio.x
|
|
findVo.y = vo.pos_y / SceneObj.LogicRealRatio.y
|
|
findVo.sceneId = scene_id
|
|
GlobalEventSystem:Fire(EventName.FIND,findVo)
|
|
if i_type == GuildModel.GuildWarTarget.Boss then
|
|
GlobalEventSystem:Fire(EventName.STARTAUTOFIGHT)
|
|
else
|
|
self:Fire(GuildModel.GUILD_WAR_START_COLLECT)
|
|
end
|
|
else
|
|
if i_type == GuildModel.GuildWarTarget.Boss then
|
|
--不做处理
|
|
Message.show("结晶守卫还未刷新，请稍后再试")
|
|
elseif i_type == GuildModel.GuildWarTarget.SmallRice then
|
|
Message.show("还未刷新,请稍后再试")
|
|
elseif i_type == GuildModel.GuildWarTarget.MiddleRice then
|
|
return false
|
|
elseif i_type == GuildModel.GuildWarTarget.BigRice then
|
|
return false
|
|
else
|
|
Message.show("还未刷新,请稍后再试")
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
--获取boss的数据
|
|
function GuildModel:GuideWarGetBossVo()
|
|
local list = SceneManager.Instance.monster_vo_list
|
|
local vo = false
|
|
for k,v in pairs(list) do
|
|
if v.type_id == GuildModel.GuildWarTarget.Boss then
|
|
vo = v
|
|
break
|
|
end
|
|
end
|
|
return vo
|
|
end
|
|
|
|
|
|
--获取boss的数据
|
|
function GuildModel:GuideWarGetTargetNum(i_type)
|
|
local list = SceneManager.Instance.monster_vo_list
|
|
local num = 0
|
|
local target_id
|
|
if i_type == GuildModel.GuildWarTarget.BigRice then
|
|
target_id = GuildModel.GuildWarTarget.BigRice
|
|
elseif i_type == GuildModel.GuildWarTarget.SmallRice then
|
|
target_id = GuildModel.GuildWarTarget.SmallRice
|
|
elseif i_type == GuildModel.GuildWarTarget.MiddleRice then
|
|
target_id = GuildModel.GuildWarTarget.MiddleRice
|
|
elseif i_type == GuildModel.GuildWarTarget.Boss then
|
|
target_id = GuildModel.GuildWarTarget.Boss
|
|
end
|
|
|
|
for k,v in pairs(list) do
|
|
if v.type_id == target_id then
|
|
num = num + 1
|
|
end
|
|
end
|
|
return num
|
|
end
|
|
|
|
--获取当前的积分奖励 返回奖励列表
|
|
function GuildModel:GuildWarGetRewardByScroe(score, show_next)
|
|
local reward_list = self.guild_war_info.reward_list
|
|
score = score or 0
|
|
|
|
if not reward_list then
|
|
reward_list = {}
|
|
local config = Config.Guildwarscorereward
|
|
for k,v in pairs(config) do
|
|
table.insert(reward_list, v)
|
|
end
|
|
table.sort(reward_list, function (a, b)
|
|
return a.score < b.score
|
|
end)
|
|
self.guild_war_info.reward_list = reward_list
|
|
end
|
|
if score < reward_list[1].score then
|
|
return show_next and stringtotable(reward_list[1].reward) or {} , false, reward_list[1].score
|
|
elseif score >= reward_list[#reward_list].score then
|
|
return stringtotable(reward_list[#reward_list].reward), true, reward_list[#reward_list].score
|
|
end
|
|
local t = {}
|
|
local cur_step_score = 0
|
|
for i,v in ipairs(reward_list) do
|
|
if reward_list[i] and reward_list[i + 1] and score >= reward_list[i].score and score < reward_list[i + 1].score then
|
|
if show_next then
|
|
t = stringtotable(reward_list[i + 1].reward)
|
|
cur_step_score = reward_list[i + 1].score
|
|
else
|
|
t = stringtotable(reward_list[i].reward)
|
|
cur_step_score = reward_list[i].score
|
|
end
|
|
break
|
|
end
|
|
end
|
|
return t, false, cur_step_score
|
|
end
|
|
|
|
--根据当前社团排名获取社团排名奖励
|
|
function GuildModel:GuildWarGetGuildRewardByRank(rank)
|
|
local config = Config.Guildwarguildreward
|
|
local reward_list = {}
|
|
for k,v in pairs(config) do
|
|
if rank >= v.rank_high and rank <= v.rank_low then
|
|
reward_list = stringtotable(v.reward)
|
|
break
|
|
end
|
|
end
|
|
return reward_list
|
|
end
|
|
|
|
--根据当前积分排名获取积分排名奖励
|
|
function GuildModel:GuildWarGetScoreRewardByRank(rank)
|
|
local config = Config.Guildwarrolereward
|
|
local reward_list = {}
|
|
for k,v in pairs(config) do
|
|
if rank >= v.rank_high and rank <= v.rank_low then
|
|
reward_list = stringtotable(v.reward)
|
|
break
|
|
end
|
|
end
|
|
return reward_list
|
|
end
|
|
|
|
--根据当前击杀排名获取击杀奖励
|
|
function GuildModel:GuildWarGetKillRewardByRank(rank)
|
|
local config = Config.Guildwarkillrank
|
|
local reward_list = {}
|
|
for k,v in pairs(config) do
|
|
if rank == v.rank then
|
|
reward_list = stringtotable(v.reward)
|
|
break
|
|
end
|
|
end
|
|
return reward_list
|
|
end
|
|
|
|
--获取当前排名的奖励列表
|
|
function GuildModel:GuildWarGetRankViewRewardByRankAndType(rank, i_type)
|
|
local reward_list = {}
|
|
if i_type == GuildWarRankView.TAB_ID.PERSON then
|
|
local config = Config.Guildwarrolereward
|
|
for k,v in pairs(config) do
|
|
if rank >= v.rank_high and rank <= v.rank_low then
|
|
reward_list = stringtotable(v.reward)
|
|
break
|
|
end
|
|
end
|
|
elseif i_type == GuildWarRankView.TAB_ID.GUILD then
|
|
local config = Config.Guildwarguildreward
|
|
for k,v in pairs(config) do
|
|
if rank >= v.rank_high and rank <= v.rank_low then
|
|
reward_list = stringtotable(v.reward)
|
|
break
|
|
end
|
|
end
|
|
--mvp社团才有mvp社团奖励
|
|
if rank == 1 then
|
|
local mvp_reward_list = stringtotable(Config.Guildwarkv["star_org_award"]["value_content"])
|
|
local not_exit_list = {}
|
|
for i,v in ipairs(mvp_reward_list) do
|
|
local is_exit = false
|
|
for ii,vv in ipairs(reward_list) do
|
|
if v[1] == vv[11] and v[2] == vv[2] then
|
|
vv[3] = vv[3] + v[3]
|
|
is_exit = true
|
|
break
|
|
end
|
|
end
|
|
if not is_exit then
|
|
table.insert(not_exit_list, v)
|
|
end
|
|
end
|
|
if #not_exit_list > 0 then
|
|
for i,v in ipairs(not_exit_list) do
|
|
table.insert(reward_list, v)
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif i_type == GuildWarRankView.TAB_ID.KILL then
|
|
local config = Config.Guildwarkillrank
|
|
for k,v in pairs(config) do
|
|
if v.rank == rank then
|
|
reward_list = stringtotable(v.reward)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return reward_list
|
|
end
|
|
|
|
--获取当前排名的奖励列表
|
|
function GuildModel:GuildWarGetRankNumByType(i_type)
|
|
self.guild_war_info = self.guild_war_info or {}
|
|
self.guild_war_info.rank_num = self.guild_war_info.rank_num or {}
|
|
if i_type == GuildWarRankView.TAB_ID.PERSON then
|
|
if not self.guild_war_info.rank_num[i_type] then
|
|
self.guild_war_info.rank_num[i_type] = {}
|
|
local config = Config.Guildwarrolereward
|
|
local max_low = 0
|
|
for k,v in pairs(config) do
|
|
if v.rank_low > max_low then
|
|
max_low = v.rank_low
|
|
end
|
|
end
|
|
for i=1,max_low do
|
|
self.guild_war_info.rank_num[i_type][i] = true
|
|
end
|
|
end
|
|
return self.guild_war_info.rank_num[i_type]
|
|
|
|
elseif i_type == GuildWarRankView.TAB_ID.GUILD then
|
|
if not self.guild_war_info.rank_num[i_type] then
|
|
self.guild_war_info.rank_num[i_type] = {}
|
|
local config = Config.Guildwarguildreward
|
|
local max_low = 0
|
|
for k,v in pairs(config) do
|
|
if v.rank_low > max_low then
|
|
max_low = v.rank_low
|
|
end
|
|
end
|
|
for i=1,max_low do
|
|
self.guild_war_info.rank_num[i_type][i] = true
|
|
end
|
|
end
|
|
return self.guild_war_info.rank_num[i_type]
|
|
|
|
elseif i_type == GuildWarRankView.TAB_ID.KILL then
|
|
if not self.guild_war_info.rank_num[i_type] then
|
|
local config = Config.Guildwarkillrank
|
|
self.guild_war_info.rank_num[i_type] = config
|
|
end
|
|
return self.guild_war_info.rank_num[i_type]
|
|
end
|
|
return {}
|
|
end
|
|
|
|
--是否还在大战中
|
|
function GuildModel:IsInGuildWar()
|
|
local cur_time = TimeUtil:getServerTime()
|
|
local t = self.guild_war_info
|
|
if t and t.end_time and t.begin_time then
|
|
return cur_time > t.begin_time and cur_time < t.end_time
|
|
end
|
|
return false
|
|
end
|
|
|
|
--获取boss下次刷新时间
|
|
function GuildModel:GuildWarGetNextBossBornTime()
|
|
if not self:IsInGuildWar() then
|
|
return 0, 0
|
|
end
|
|
local cur_time = TimeUtil:getServerTime()
|
|
local config = Config.Guildwarkv.refresh_boss
|
|
local t = stringtotable(config.value_content)
|
|
local list = {}
|
|
for i,v in ipairs(t) do
|
|
--第几个boss出生的时间，是前面的时间的总和
|
|
local total_time = 0
|
|
for ii=1,i do
|
|
total_time = tonumber(t[ii]) + total_time
|
|
end
|
|
table.insert(list, total_time + self.guild_war_info.begin_time)
|
|
end
|
|
local time = 0 --刷新时间
|
|
local idx = 0 --第几只boss
|
|
for i,v in ipairs(list) do
|
|
if cur_time <= v then
|
|
time = v
|
|
idx = i
|
|
break
|
|
end
|
|
end
|
|
return time, idx
|
|
end
|
|
|
|
--检测活动是否开放
|
|
function GuildModel:GuildWarCheckIconBoolOpen(state, end_time)
|
|
local vo =
|
|
{
|
|
state = state,
|
|
etime = end_time,
|
|
}
|
|
self:SetGuildEventByType(GuildEventType.GuildWar, vo)
|
|
end
|
|
|
|
--是否是本服团战交粮的npcid
|
|
function GuildModel:IsGuildWarNpcId(type_id)
|
|
return (type_id == GuildModel.GuildWarTarget.Npc_1) or (type_id == GuildModel.GuildWarTarget.Npc_2) or (type_id == GuildModel.GuildWarTarget.Npc_3)
|
|
end
|
|
|
|
GuildModel.GUILD_WAR_NPC_TALK_CONTENT =
|
|
{
|
|
[1] = "干得好，这正是我们急需的物资！",
|
|
[2] = "请先去采集物资再来吧！\n<color=#2CF86F>(高级物资需击杀BOSS掉落)</color>",
|
|
}
|
|
|
|
--获取Npc对话文本
|
|
function GuildModel:GetGuildWarNpcTalkContent()
|
|
if self:GuildWarIsInPickState() then
|
|
return GuildModel.GUILD_WAR_NPC_TALK_CONTENT[1]
|
|
end
|
|
return GuildModel.GUILD_WAR_NPC_TALK_CONTENT[2]
|
|
end
|
|
|
|
--是否在采集状态
|
|
function GuildModel:GuildWarIsInPickState()
|
|
return SceneManager.Instance:IsGuildWarScene() and
|
|
SceneManager:getInstance():IsGuildWarScene() and self.guild_war_info.pick_id and self.guild_war_info.pick_id ~= 0
|
|
end
|
|
--------------------------本服团战相关 结束--------------------------
|
|
--------------------------本国团战相关 start--------------------------
|
|
function GuildModel:CalInCSGRSafePos(pos_x, pos_y)
|
|
-- 如果存在活动且在入场阶段，则需要限制在安全区内
|
|
if self.guild_evt_data[GuildEventType.GuildCSGR] and self.guild_evt_data[GuildEventType.GuildCSGR].status == 1 then
|
|
if SceneManager.Instance:IsSafePos(pos_x, pos_y) then -- 安全区内，自由移动
|
|
-- 缓存当前帧所在的坐标
|
|
self.csgr_scene_last_pos.x = pos_x
|
|
self.csgr_scene_last_pos.y = pos_y
|
|
return pos_x, pos_y
|
|
else
|
|
-- 当前位置会超出安全区，则需要返回上一帧的坐标
|
|
if self.csgr_scene_last_pos.x == 0 or self.csgr_scene_last_pos.y == 0 then
|
|
return pos_x, pos_y
|
|
else
|
|
return self.csgr_scene_last_pos.x, self.csgr_scene_last_pos.y
|
|
end
|
|
end
|
|
else
|
|
return pos_x, pos_y
|
|
end
|
|
end
|
|
-- 根据不同的需求获取本国团战采集怪配置
|
|
function GuildModel:GetCSGRCollectCfg(attr_id)
|
|
self.csgr_collect_cfg_data = self.csgr_collect_cfg_data or stringtotable(Config.Campwarkv["material_attr"].val)
|
|
if not self.csgr_collect_cfg_data2 then
|
|
self.csgr_collect_cfg_data2 = {}
|
|
for k, v in ipairs(self.csgr_collect_cfg_data) do
|
|
self.csgr_collect_cfg_data2[v[1]] = v
|
|
end
|
|
end
|
|
if attr_id then
|
|
return self.csgr_collect_cfg_data2[attr_id]
|
|
else
|
|
return self.csgr_collect_cfg_data
|
|
end
|
|
end
|
|
function GuildModel:GetCSGRCurBossHp( )
|
|
local percentage = 1
|
|
local max_hp = 10000000000000
|
|
local event_data = self:GetGuildEventByType(GuildEventType.GuildCSGR)
|
|
if event_data and event_data.status == 3 then
|
|
local total_time = event_data.end_time - event_data.start_time - 5
|
|
local pass_time = TimeUtil:getServerTime() - event_data.start_time
|
|
percentage = 1 - (pass_time / total_time)
|
|
percentage = percentage <= 0 and 0 or percentage
|
|
else
|
|
percentage = 0
|
|
end
|
|
local monsterHp = max_hp * percentage
|
|
return monsterHp, max_hp, percentage
|
|
end
|
|
-- 血量变化计时器
|
|
function GuildModel:StartCSGRBossHpTimer( )
|
|
self:StopCSGRBossHpTimer()
|
|
local function csgr_boss_hp_func()
|
|
local monsterHp, max_hp, percentage = self:GetCSGRCurBossHp()
|
|
self:Fire(GuildModel.UPDATE_CSGR_BOSS_HP, monsterHp, max_hp, percentage)
|
|
end
|
|
self.guild_csgr_hp_timer = GlobalTimerQuest:AddPeriodQuest(csgr_boss_hp_func, 0.5, -1)
|
|
end
|
|
function GuildModel:StopCSGRBossHpTimer( )
|
|
if self.guild_csgr_hp_timer then
|
|
GlobalTimerQuest:CancelQuest(self.guild_csgr_hp_timer)
|
|
self.guild_csgr_hp_timer = nil
|
|
end
|
|
end
|
|
-- 判断当前本国团战是否在采集阶段
|
|
function GuildModel:IsCSGRInCollectRound( )
|
|
local b = false
|
|
local event_data = self:GetGuildEventByType(GuildEventType.GuildCSGR)
|
|
if event_data then
|
|
b = event_data.status == 2 -- 2为采集阶段
|
|
end
|
|
return b
|
|
end
|
|
-- 更新本国团战自动采集状态
|
|
function GuildModel:UpdateCSGRAutoCollectFlag(flag)
|
|
self.csgr_auto_collect = false
|
|
-- 场景内切换自动采集，中断当前的采集状态
|
|
if SceneManager:getInstance():IsGuildCSGRScene() and self:IsCSGRInCollectRound() then
|
|
GlobalEventSystem:Fire(EventName.CANCEL_TO_COLLECT)
|
|
Scene.Instance:CancelClickTarget(nil,true) --把目标清掉
|
|
self.csgr_auto_collect = flag
|
|
end
|
|
end
|
|
function GuildModel:GetCSGRAUtoCollectStatus( )
|
|
return self.csgr_auto_collect
|
|
end
|
|
function GuildModel:CSGRAutoCollect()
|
|
if self.csgr_auto_collect then
|
|
local nearest_mon = Scene:getInstance():GetNearestGuildCollectMonsterByTypeId()
|
|
if nearest_mon then
|
|
local function call_back()
|
|
Scene.Instance:SetClickTarget(nearest_mon, true)
|
|
end
|
|
local findVo = FindVo.New()
|
|
findVo.type = FindVo.MONSTER
|
|
findVo.x = nearest_mon.vo.pos_x / SceneObj.LogicRealRatio.x
|
|
findVo.y = nearest_mon.vo.pos_y / SceneObj.LogicRealRatio.y
|
|
findVo.sceneId = SceneManager:getInstance():GetSceneId()
|
|
findVo.id = nearest_mon.vo.type_id
|
|
findVo.call_back = call_back
|
|
GlobalEventSystem:Fire(EventName.FIND, findVo)
|
|
else -- 没有采集物，或者在九宫格以外，需要前端查找可以采集的对象发送协议自动移动到目的地
|
|
local temp_buff_list = {} -- 临时表，用来存储有剩余的采集buff信息
|
|
local collect_cfg_data = self:GetCSGRCollectCfg()
|
|
-- 筛选出当前还有剩余的采集物
|
|
for k, v in ipairs(collect_cfg_data) do
|
|
local buff_data = self:GetCSGRBattlefieldRes(v[1])
|
|
if buff_data and buff_data.num > 0 then
|
|
table.insert(temp_buff_list, v)
|
|
end
|
|
end
|
|
local ramdom_cfg = temp_buff_list[math.random(1, #temp_buff_list)]
|
|
local attr_icon = ramdom_cfg and ramdom_cfg[1]
|
|
if attr_icon then
|
|
self:Fire(GuildModel.REQUEST_CCMD_EVENT, 41008, attr_icon)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
--------------------------本国团战相关 end--------------------------
|
|
--------- 社团数据获取相关代码 end ---------
|
|
|
|
--获取社团竞榜增加人数
|
|
function GuildModel:GetAddMemNum( )
|
|
if GuildModel:getInstance().base_info and GuildModel:getInstance().base_info.add_mem_num then
|
|
return GuildModel:getInstance().base_info.add_mem_num
|
|
end
|
|
return 0
|
|
end
|
|
|
|
--判断是否是社团类功能id
|
|
function GuildModel:GetIsGuildModel( model_id )
|
|
model_id = model_id or 0
|
|
self.guild_model_id_list = self.guild_model_id_list or {[142] = true,[400] = true,[405] = true,[406] = true,[408] = true}
|
|
return self.guild_model_id_list[model_id] and true or false
|
|
end
|
|
|
|
----------社团跑环答题-start---------
|
|
-- 获取最大答题数 需要答对数
|
|
function GuildModel:GetQuizTimesKv( )
|
|
local cfg = stringtotable(Config.Guildrunassistkv["answer_times"].val)
|
|
return cfg[1], cfg[2]
|
|
end
|
|
|
|
-- 设置答题数据
|
|
function GuildModel:SetGuildQuizID( vo )
|
|
self.cur_guild_quiz_id = vo.quiz_id
|
|
self.guild_quiz_seq = vo.index
|
|
end
|
|
|
|
-- 获取当前题目id 和 题目索引
|
|
function GuildModel:GetGuildQuizID( )
|
|
return self.cur_guild_quiz_id, self.guild_quiz_seq
|
|
end
|
|
|
|
-- 初始化答题数据
|
|
function GuildModel:InitGuildQuizData( support_sid )
|
|
-- self.guild_quiz_seq = 1 -- 进度第一题
|
|
self.cur_guild_quiz_id = nil
|
|
self.guild_quiz_seq = 1
|
|
self.guild_quiz_get_times = 0 -- 答对的数目
|
|
self.guild_quiz_support_sid = support_sid or 0 -- 本次答题的协助id
|
|
end
|
|
|
|
-- 获取本次答题协助剩余时间
|
|
function GuildModel:GetCurQuizRemainTime( )
|
|
local data = self:GetGuildSupportInfoById( self.guild_quiz_support_sid )
|
|
if not data then return 0 end
|
|
local _, end_time = self:ParseData(data.kv_data)
|
|
local time = end_time - TimeUtil:getServerTime( )
|
|
return time
|
|
end
|
|
|
|
-- 答题后的数据更新 41702
|
|
function GuildModel:UpdateGuildQuizData( vo )
|
|
self.guild_quiz_get_times = vo.success_quiz
|
|
end
|
|
|
|
-- 获取答对的题目数
|
|
function GuildModel:GetCurCorrectTimes( )
|
|
return self.guild_quiz_get_times or 0
|
|
end
|
|
|
|
-- 获取答题协助奖励列表
|
|
function GuildModel:GetGuildQuizAwardList( )
|
|
-- local temp_award_list = DeepCopy(self.guild_support_cfg[5].support_reward)
|
|
local reward_reputation_count = self.guild_support_cfg[5].reward_reputation
|
|
-- table.insert(temp_award_list, {100, 100003, reward_reputation_count} )
|
|
local temp_award_list = {
|
|
{100, 100003, reward_reputation_count},
|
|
}
|
|
return temp_award_list
|
|
end
|
|
|
|
-- 设置结算数据 41703
|
|
function GuildModel:SetGuildQuizResultData( vo )
|
|
self.quiz_res = vo.res
|
|
end
|
|
|
|
-- 获取答题结果
|
|
function GuildModel:GetGuildQuizResultData( )
|
|
return self.quiz_res
|
|
end
|
|
|
|
-- 重连初始化答题数据
|
|
function GuildModel:ReLinkInitGuildQuizData( vo )
|
|
self.guild_quiz_seq = vo.index or 1 -- 进度第几题
|
|
self.guild_quiz_get_times = vo.success_quiz or 0 -- 答对的数目
|
|
self.guild_quiz_support_sid = vo.sid or 0 -- 本次答题的协助id
|
|
self.cur_guild_quiz_id = vo.quiz_id or 0 -- 当前题目
|
|
end
|
|
|
|
-- 设置战场活动提示红点
|
|
function GuildModel:SetWarActiveRedDot(module_id, module_sub, state)
|
|
local key = module_id .. "@" .. module_sub
|
|
self.war_active_show_red_dot[key] = state or false
|
|
self:Fire(GuildModel.SHOW_ACTIVE_OPEN_TIPS_RED)
|
|
end
|
|
|
|
--获取战场提示红点
|
|
function GuildModel:GetWarActiveRedDot(module_id, module_sub)
|
|
local key = module_id .. "@" .. module_sub
|
|
return self.war_active_show_red_dot[key] or false
|
|
end
|
|
|
|
|
|
function GuildModel:ParseData(str)
|
|
local bosspower = 0
|
|
local end_time = 0
|
|
local boss_id = 0
|
|
local dun_id = 0
|
|
local status = 0
|
|
if str and str ~= "" then
|
|
local info = stringtotable(str)
|
|
if info and #info > 0 then
|
|
for i,v in ipairs(info) do
|
|
local key = tonumber(v[1])
|
|
if key == 1 then
|
|
bosspower = tonumber(v[2])
|
|
elseif key == 2 then
|
|
end_time = tonumber(v[2])
|
|
elseif key == 3 then
|
|
boss_id = tonumber(v[2])
|
|
elseif key == 4 then
|
|
dun_id = tonumber(v[2])
|
|
elseif key == 5 then
|
|
status = tonumber(v[2])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return bosspower, end_time, boss_id, dun_id, status
|
|
end
|
|
----------社团跑环答题-end-----------
|