yzyCli/u3d/Lua/game/guild/GuildModel.lua

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