JumpOneModel = JumpOneModel or BaseClass(BaseVo, true)
local JumpOneModel = JumpOneModel

JumpOneModel.REQUEST_INFO = "JumpOneModel.REQUEST_INFO"--请求协议
JumpOneModel.OPEN_JUMP_ONE_MAIN_VIEW = "JumpOneModel.OPEN_JUMP_ONE_MAIN_VIEW"--打开活动主界面
JumpOneModel.OPEN_JUMP_ONE_SCENE_VIEW = "JumpOneModel.OPEN_JUMP_ONE_SCENE_VIEW"--打开跳一跳场景界面
JumpOneModel.JUMP_UPDATE_BASEINFO = "JumpOneModel.JUMP_UPDATE_BASEINFO"--跳一跳刷新匹配信息
JumpOneModel.JUMP_UPDATE_MATCHINFO = "JumpOneModel.JUMP_UPDATE_MATCHINFO"--跳一跳刷新匹配信息
JumpOneModel.JUMP_UPDATE_MATCH_MEMBERS = "JumpOneModel.JUMP_UPDATE_MATCH_MEMBERS"--跳一跳刷新匹配队员
JumpOneModel.JUMP_UPDATE_GAME_INFO = "JumpOneModel.JUMP_UPDATE_GAME_INFO"--跳一跳游戏信息
JumpOneModel.JUMP_UPDATE_READY_TIME = "JumpOneModel.JUMP_UPDATE_READY_TIME"--跳一跳准备倒计时
JumpOneModel.JUMP_ADD_STEP = "JumpOneModel.JUMP_ADD_STEP"--跳一跳增加跳台
JumpOneModel.JUMP_START_JUMP = "JumpOneModel.JUMP_START_JUMP"--跳一跳开始跳跃
JumpOneModel.JUMP_UPDATE_MEMBER_INFO = "JumpOneModel.JUMP_UPDATE_MEMBER_INFO"--跳一跳更新玩家信息
JumpOneModel.JUMP_OFF_LINE_UPDATE = "JumpOneModel.JUMP_OFF_LINE_UPDATE"--跳一跳离线更新
JumpOneModel.JUMP_ON_LINE_UPDATE = "JumpOneModel.JUMP_ON_LINE_UPDATE"--跳一跳上线更新
JumpOneModel.OPEN_JUMP_ONE_RESULT_VIEW = "JumpOneModel.OPEN_JUMP_ONE_RESULT_VIEW"--跳一跳上结算界面
JumpOneModel.JUMP_END_NOTIFY = "JumpOneModel.JUMP_END_NOTIFY"--跳一跳跳跃结果通知
JumpOneModel.JUMP_GAME_END_NOTIFY = "JumpOneModel.JUMP_GAME_END_NOTIFY"--跳一跳游戏结束
JumpOneModel.JUMP_GAME_RESULT_NOTIFY = "JumpOneModel.JUMP_GAME_RESULT_NOTIFY"--跳一跳游戏结算

local GameMath_GetDistance = GameMath.GetDistance

function JumpOneModel:__init()
	JumpOneModel.Instance = self
	self:Reset()
end

JumpOneModel.STEP_START_ID = 1000

JumpOneModel.SCENE_HEIGHT = 1.1

JumpOneModel.GAME_STATE = 
{
	WAIT = 1,
	READY = 2,
	GAME = 3,
	END = 4,
}

JumpOneModel.JUMP_TOUCH_STATE = 
{
	NONE = 1,
	DOWN = 2,
	UP = 3,
	END = 4,
}

JumpOneModel.PLAYER_STATE = 
{
	OFF_LINE = 0,	--离线
	ON_LINE = 1,	--正常在线
	WAITING = 2,	--等待进场	
	GAME_OUT = 3,	--已经淘汰
}

function JumpOneModel:Reset()	
	self.view_info = {}--界面信息
	self.reward_info = {}--奖励列表
	self.game_info = {} --游戏信息
	self.act_cfg = {}	--活动配置
	self.result_info = false--结算数据
	self.is_quit_game = false--是否手动退出
end

function JumpOneModel:getInstance()
	if JumpOneModel.Instance == nil then
		JumpOneModel.Instance = JumpOneModel.New()
	end
	return JumpOneModel.Instance
end

--检测竞榜和图标是否需要开启
function JumpOneModel:SetActCfg(vo)
	self.act_cfg = {}
	self.act_cfg[vo.sub_type] = vo
end

--获取活动配置
function JumpOneModel:GetActCfg()
	for k,v in pairs(self.act_cfg) do
		return v
	end
end

--检测竞榜和图标是否需要开启
function JumpOneModel:CheckJumpOneIconBoolOpen()
	if #self.act_cfg == 0 then
		return
	end
	if not GetModuleIsOpen(331, 121, true) then
		return
	end
	local base_type = CustomActivityModel.CustomActBaseType.JUMP_ONE
	for k,v in pairs(self.act_cfg) do
		local icon_sub_type = base_type*1000 + v.sub_type
		if v.sub_type >= 10001 then
			icon_sub_type = base_type*100000 + v.sub_type
		end
		local cfg = v
		if cfg and self.view_info and self.view_info.base_info and self.view_info.base_info.end_time then
			local server_time = TimeUtil:getServerTime()
			local is_open = self.view_info.base_info.end_time - server_time
			if is_open > 0 then
				ActivityIconManager:getInstance():addIcon(icon_sub_type, is_open)
			else
				ActivityIconManager:getInstance():deleteIcon(icon_sub_type)
			end			
		else
			ActivityIconManager:getInstance():deleteIcon(icon_sub_type)
		end
	end
end

--检测竞榜和图标是否需要显示匹配
function JumpOneModel:CheckJumpOneIconMatch()
	if #self.act_cfg == 0 then
		return
	end
	if not GetModuleIsOpen(331, 121, true) then
		return
	end
	local base_type = CustomActivityModel.CustomActBaseType.JUMP_ONE
	for k,v in pairs(self.act_cfg) do
		local sub_base_type = base_type*1000
		local cfg = v
		if cfg then
			GlobalEventSystem:Fire(ActivityIconManager.UPDATE_FUNCICON_SPECIAL_TIPS, sub_base_type+v.sub_type)
		end
	end
end

--设置活动开放信息
function JumpOneModel:SetOpenInfo(vo)
	self.view_info.base_info = self.view_info.base_info or {}
	self.view_info.base_info.end_time = vo.end_time
	self:CheckJumpOneIconBoolOpen()
end

--设置基本信息
function JumpOneModel:SetJumoOneInfo(vo)
	self.view_info = self.view_info or {}
	self.view_info.base_info = vo
	self:CheckJumpOneIconBoolOpen()
	self:Fire(JumpOneModel.JUMP_UPDATE_BASEINFO)
end

--设置匹配信息
function JumpOneModel:SetJumoOneMatchInfo(vo)
	self.view_info = self.view_info or {}
	self.view_info.match_info = vo
	self:CheckJumpOneIconMatch()
	self:Fire(JumpOneModel.JUMP_UPDATE_MATCHINFO)
end

--当前是否在匹配状态
function JumpOneModel:IsInJumoOneMatchState()
	if self.view_info and self.view_info.match_info then
		return self.view_info.match_info.status == 1
	end
	return false
end

--设置匹配队员列表
function JumpOneModel:SetJumoOneMatchMembers(vo)
	self.view_info = self.view_info or {}
	self.view_info.match_members = vo
	self:Fire(JumpOneModel.JUMP_UPDATE_MATCH_MEMBERS)
end

--当前是否在匹配状态
function JumpOneModel:GetJumoOneMatchMembers()
	if self.view_info and self.view_info.match_members then
		return self.view_info.match_members.role_list
	end
	return nil
end

--清除匹配状态
function JumpOneModel:ResetJumoOneMatchInfo()
	self.view_info = {}
	self.game_info = {}
	self:CheckJumpOneIconMatch()
end

--设置跳一跳开始倒计时时间
function JumpOneModel:SetJumpOneReadyTIme(vo)
	self.game_info = self.game_info or {}
	self.game_info.ready_info = vo
	self.game_info.ready_info.left_time = vo.time - TimeUtil:getServerTime() + 1
	self.game_info.game_state = JumpOneModel.GAME_STATE.READY
	self:Fire(JumpOneModel.JUMP_UPDATE_READY_TIME)
end

--设置跳一跳游戏信息
function JumpOneModel:SetJumpOneGameInfo(vo)
	self.game_info = {}
	self.game_info.game_info = vo
	self.game_info.game_state = JumpOneModel.GAME_STATE.WAIT
	local step_vo = 
	{
		x = vo.x,
		y = vo.y,
		picture = vo.picture,
		radius = vo.radius,
		is_new = false,
	} 	
	vo.step_list = 
	{
		[1] = step_vo,
	}
	if vo and #vo.step_list > 0 then
		for i,v in ipairs(vo.step_list) do
			v.step_id = JumpOneModel.STEP_START_ID + i
			Scene.Instance:CreateJumpOneStep(v, v.step_id)
		end
	end	
	local role_list = vo.role_list
	for i,v in ipairs(role_list) do
		if v.life ~= 0 then
			if v.online == 1 then
				v.player_state = JumpOneModel.PLAYER_STATE.ONELINE
			else
				v.player_state = JumpOneModel.PLAYER_STATE.WAITING
			end	
		else
			v.player_state = JumpOneModel.PLAYER_STATE.GAME_OUT
		end		
	end
	self.game_info.game_info.role_list = role_list
	self:SyncAllRolePos(vo.x, vo.y)
	self:UpdateMemberVisible()
	self.is_quit_game = false
	self:Fire(JumpOneModel.JUMP_UPDATE_GAME_INFO)
end

--设置跳一跳新跳台
function JumpOneModel:JumpOneAddNewStep(vo)
	if not vo then
		return
	end
	local step_vo = 
	{
		x = vo.x,
		y = vo.y,
		picture = vo.picture,
		radius = vo.radius,
		is_end = vo.is_end,
		is_new = true,
	} 
	self.game_info.game_info = self.game_info.game_info or {}
	self.game_info.game_info.step_list = self.game_info.game_info.step_list or {}
	local list = self.game_info.game_info.step_list
	local step_id = JumpOneModel.STEP_START_ID + 1
	if #list >= 5 then		
		local step_info = list[1]
		Scene.Instance:DeleteJumpOneStep(step_info.step_id)
		table.remove(list, 1)			
	end
	if #list > 0 then
		step_id = list[#list].step_id + 1
	end
	step_vo.step_id = step_id
	table.insert(list , step_vo)
	self.game_info.game_info.step_list = list
	Scene.Instance:CreateJumpOneStep(step_vo, step_vo.step_id)
	self:UpdateMemberDir(vo.x, vo.y)
end

--设置跳一跳新跳台
function JumpOneModel:StartJump(vo)
	if not vo then
		return
	end
	self.game_info.is_sync_pos = false
	self.game_info.game_info = self.game_info.game_info or {}
	self.game_info.game_info.cur_jump_info = vo
	local left_jump_time = vo.jump_time - TimeUtil:getServerTime()
	local max_jump_time = self:GetMaxJumpTime()
	self.game_info.game_info.cur_jump_info.left_jump_time = left_jump_time > max_jump_time and max_jump_time or left_jump_time
	self.game_info.game_info.cur_jump_info.max_jump_time = max_jump_time
	self.game_info.game_info.round = vo.round
	self.game_info.game_state = JumpOneModel.GAME_STATE.GAME
	self:SetJumpTouchState(JumpOneModel.JUMP_TOUCH_STATE.NONE)
	local main_role = Scene.Instance.main_role
	if main_role then
		local pos_x, pos_y =  main_role:GetRealPos()
		self:SyncAllRolePos(pos_x, pos_y)
	end
	self:UpdateMemberVisible()
	self:Fire(JumpOneModel.JUMP_START_JUMP)

end

--是否是我的回合
function JumpOneModel:IsMyTurn()
	local cur_jump_info = self.game_info.game_info and self.game_info.game_info.cur_jump_info
	if cur_jump_info and RoleManager.Instance.mainRoleInfo.role_id == cur_jump_info.role_id then
		return true
	end
end

--获取当前回合
function JumpOneModel:GetCurTurn()
	if self.game_info.game_info and self.game_info.game_info.round then
		return self.game_info.game_info.round
	end
	return 1
end

--跳一跳获取房间id
function JumpOneModel:GetRoomId()
	return self.game_info.game_info and self.game_info.game_info.room_id or 1
end

--跳一跳跳跃处理
function JumpOneModel:JumpOneDoJumpHandle(role_id, jump_time)
	local role = Scene.Instance:GetRole(role_id)
	local last_step_info = self:GetLastStepInfo()
	if role and last_step_info then		
		if jump_time > self:GetJumpMaxTouchTime() then
			jump_time = self:GetJumpMaxTouchTime()
		end
		local is_success = self:CheckJumpResult(role, jump_time, last_step_info.x, last_step_info.y)		
		local distance = nil
		local dir = role.direction
		local dist,move_hspeed,move_vspeed = role:GetGameJumpDistanceAndSpeed(jump_time)
		local end_pos = co.TableXY(math.floor(role.real_pos.x + dir.x * dist) , math.floor(role.real_pos.y + dir.y * dist))
		local start_pos = co.TableXY(role.real_pos.x, role.real_pos.y)
		local function onJumpEnd()
			self:Fire(JumpOneModel.JUMP_END_NOTIFY, is_success and 1 or 0)
		end
		role:DoGameFlyJump(end_pos,start_pos,move_hspeed,move_vspeed,onJumpEnd,not is_success)
		if self:IsMyTurn() then
			self:SyscJumpHandle(end_pos.x, end_pos.y, jump_time, is_success)
		end
	end
end


--跳一跳跳跃处理
function JumpOneModel:JumpOneDoJumpHandleFromServer(role_id, jump_time,status, pos_x, pos_y)
	local last_step_info = self:GetLastStepInfo()
	local role_list = self:GetGameMemberInfo()
	if last_step_info and role_list and #role_list > 0 then
		for k,v in pairs(role_list) do
			if self:IsMyTurn()  then
				if status == 1 and v.role_id ~= RoleManager.Instance.mainRoleInfo.role_id then
					local role =  Scene.Instance:GetRole(v.role_id)
					if role then
						role:SetRealPos(pos_x, pos_y)
					end
				end
			else
				if v.role_id == role_id then
					local role = Scene.Instance:GetRole(v.role_id)					
					if role then
						local is_success = status == 1
						local distance = nil
						local dir = role.direction
						local dist,move_hspeed,move_vspeed = role:GetGameJumpDistanceAndSpeed(jump_time)
						local end_pos = co.TableXY(math.floor(role.real_pos.x + dir.x * dist) , math.floor(role.real_pos.y + dir.y * dist))
						local start_pos = co.TableXY(role.real_pos.x, role.real_pos.y)					
						local function onJumpEnd()
							if status == 1 then
								--如果触发到了下一个传送点，则同步到下一个传送点的位置
								print('Cat:JumpOneModel.lua[353] data', self.game_info.is_sync_pos, pos_x, pos_y)
								if self.game_info.is_sync_pos then
									PrintTable(self.game_info.is_sync_pos)
									self:SyncAllRolePos(self.game_info.is_sync_pos.x, self.game_info.is_sync_pos.y)
								else
									self:SyncAllRolePos(pos_x, pos_y)
								end								
							end							
							self:Fire(JumpOneModel.JUMP_END_NOTIFY, status)
						end
						role:DoGameFlyJump(end_pos,start_pos,move_hspeed,move_vspeed,onJumpEnd,not is_success, true)
					end
				end			
			end
		end
	end
end

--等待玩家跳跃完成，在同步位置
function JumpOneModel:SyncAllRolePos(x, y )
	local role_list = self:GetGameMemberInfo()
	if role_list and #role_list > 0 then
		for k,v in pairs(role_list) do
			local role = Scene.Instance:GetRole(v.role_id)		
			if role then
				role:SetRealPos(x, y)
			end
		end
	end
end

--等待玩家跳跃完成，在同步位置
function JumpOneModel:SyncTargetRolePos(x, y,role_id)
	local role_list = self:GetGameMemberInfo()
	if role_list and #role_list > 0 then
		for k,v in pairs(role_list) do
			if v.role_id == role_id then
				local role = Scene.Instance:GetRole(v.role_id)		
				if role then
					role:SetRealPos(x, y)
				end
				break
			end			
		end
	end
end


--跳一跳完美跳跃 *********** 内挂
function JumpOneModel:JumpOneDoMvpJumpHandle(role_id)
	local role = Scene.Instance:GetRole(role_id)
	local last_step_info = self:GetLastStepInfo()
	if role and last_step_info then
		local is_success = true				
		local end_pos = co.TableXY(last_step_info.x , last_step_info.y)
		local start_pos = co.TableXY(role.real_pos.x, role.real_pos.y)
		local dis = GameMath_GetDistance(end_pos.x, end_pos.y, start_pos.x, start_pos.y, true)
		local move_hspeed ,move_vspeed, jump_time = role:GetGameMvpJumpSpeedAndTime(dis)
		local function onJumpEnd()
			self:Fire(JumpOneModel.JUMP_END_NOTIFY, 1)
		end
		role:DoGameFlyJump(end_pos,start_pos,move_hspeed,move_vspeed,onJumpEnd,not is_success)
		jump_time = math.floor(jump_time * 1000)
		if self:IsMyTurn() then
			self:SyscJumpHandle(end_pos.x, end_pos.y, jump_time, is_success)
		end				
		--GlobalEventSystem:Fire(SceneEventType.GAME_FLY_JUMP, jump_time,nil,nil,nil,nil,is_fail)
	end
end

--跳一跳同步跳跃
function JumpOneModel:SyscJumpHandle(pos_x, pos_y, jump_time, is_success)
	local room_id = self:GetRoomId()
	local status = is_success and 1 or 0
	local ticket =  string.lower(Util.md5(room_id .. pos_x .. pos_y .. status .. jump_time .. "666JKLSDFRTYABJK666"))
	local sub_type = self:GetActSubType()
	self:Fire(JumpOneModel.REQUEST_INFO, 45910,room_id, pos_x, pos_y, status, jump_time, ticket, sub_type)
end

--跳一跳，服务器返回起跳准备处理
function JumpOneModel:JumpOneReadyJumpHandleFromServer(role_id)	
	--每次起跳前，同步下所有人的坐标和朝向
	local main_role = Scene.Instance.main_role
	if main_role then
		local pos_x, pos_y =  main_role:GetRealPos()
		self:SyncAllRolePos(pos_x, pos_y)
	end
	
	local last_step_info = self:GetLastStepInfo()	
	if last_step_info then
		self:UpdateMemberDir(last_step_info.x, last_step_info.y)	
	end	
	self:JumpOneReadyJumpHandle(role_id, true)
end


--跳一跳起跳跳跃处理
function JumpOneModel:JumpOneReadyJumpHandle(role_id, from_server)
	if from_server and role_id == RoleManager.Instance.mainRoleInfo.role_id then
		return
	end
	local role = Scene.Instance:GetRole(role_id)
	if role then
		role:DoGameReadyJump()
	end
end

--跳一跳起跳跳跃处理
function JumpOneModel:JumpOneJumpHandle(role_id)
	local role = Scene.Instance:GetRole(role_id)
	if role then
		role:DoGameReadyJump()
	end
end

--跳一跳摔倒处理
function JumpOneModel:JumpOneJumpDownHandle(role_id)
	local role = Scene.Instance:GetRole(role_id)
	if role then
		role:DoGameDownJump()
	end
end

--跳一跳更新玩家信息
function JumpOneModel:UpdateMemberInfo(vo)
	local role_list = self:GetGameMemberInfo()
	if role_list and #role_list > 0 then
		for k,v in pairs(role_list) do
			if v.role_id == vo.role_id then
				v.life = vo.life								
				if v.life == 0 then
					v.player_state = JumpOneModel.PLAYER_STATE.GAME_OUT			
				end
				self:Fire(JumpOneModel.JUMP_UPDATE_MEMBER_INFO)
				break
			end			
		end
	end
end

--跳一跳更新玩家信息
function JumpOneModel:GetGameMemberInfo()
	local list = {}
	if self.game_info and self.game_info.game_info then
		list = self.game_info.game_info.role_list
	end
	return list
end

--跳一跳更新玩家信息
function JumpOneModel:GetGameMyInfo()
	local role_list = self:GetGameMemberInfo()
	if role_list and #role_list > 0 then
		for k,v in pairs(role_list) do
			if v.role_id == RoleManager.Instance.mainRoleInfo.role_id then
				return v
			end			
		end
	end
end

--跳一跳更新玩家信息
function JumpOneModel:UpdateMemberDir(target_x, target_y)
	local role_list = self:GetGameMemberInfo()
	local dir2 = Vector2.New(0, 1)
	if not role_list or #role_list == 0 then
		return
	end
	for i,v in ipairs(role_list) do
		local role = Scene.Instance:GetRole(v.role_id)
		if role then
			local pos_x, pos_y =  role:GetRealPos()
			local dir1 = Vector2.New(target_x - pos_x , target_y - pos_y )
			dir1 = dir1:Normalize()
			local rotate_y =  Vector2.Angle(dir1, dir2)
			role:SetDirection(Vector2.New(pos_x, pos_y), Vector2.New(target_x, target_y), true)
		end
	end
end

--跳一跳检测跳跃成功还是失败
function JumpOneModel:CheckJumpResult(role, jump_time, target_x, target_y)
	if role then
		local cur_jump_info = self:GetCurJumpInfo()
		local last_step_info = self:GetLastStepInfo()
		local step_radius = last_step_info.radius / 100 / 2 + 1
		local dist = role:GetGameJumpDistanceAndSpeed(jump_time)
		local dir = role.direction
		local end_pos = co.TableXY(role.real_pos.x + dir.x * dist, role.real_pos.y + dir.y * dist)
		local pos_1_x = end_pos.x / MainCamera.PixelsToUnits
		local pos_1_y = end_pos.y / MainCamera.PixelsToUnits
		local pos_2_x = target_x / MainCamera.PixelsToUnits
		local pos_2_y = target_y / MainCamera.PixelsToUnits		
		local length = GameMath_GetDistance(pos_1_x, pos_1_y, pos_2_x, pos_2_y, false)				
		print('Cat:JumpOneModel.lua[539] cur pos ', pos_1_x, pos_1_y, pos_2_x, pos_2_y)
		print('Cat:JumpOneModel.lua[332] length', length, step_radius, length <= step_radius)
		return length <= step_radius
	end
	return false
end


--跳一跳获取当前跳跃的信息
function JumpOneModel:GetCurJumpInfo()
	local cur_jump_info = self.game_info.game_info and self.game_info.game_info.cur_jump_info or false
	return cur_jump_info
end

--跳一跳获取最新一个跳台的信息
function JumpOneModel:GetLastStepInfo()
	local step_info 
	if self.game_info.game_info and self.game_info.game_info.step_list then
		local list = self.game_info.game_info.step_list
		step_info = list[#list]
	end
	return step_info 
end

--跳一跳清除所有跳台
function JumpOneModel:ClearAllStep()
	local step_list = self.game_info.game_info and self.game_info.game_info.step_list or false
	if step_list and #step_list > 0 then
		for k,v in pairs(step_list) do
			Scene.Instance:DeleteJumpOneStep(v.step_id)
		end
	end
end

--跳一跳内部切场景
function JumpOneModel:SyncGameScene(vo)
	self.game_info.is_sync_pos = vo
	local main_role = Scene.Instance.main_role
	if main_role and vo  then
		main_role:SetRealPos(vo.x, vo.y)
		GlobalEventSystem:Fire(SceneEventType.MOVEREQUEST, vo.x, vo.y, MOVE_TYPE.BLINK)
	end
end

--跳一跳更新玩家的显示状态
function JumpOneModel:UpdateMemberVisible()
	local show_role_id = false
	local game_state = self:GetGameState()
	if game_state == JumpOneModel.GAME_STATE.GAME and not self.is_quit_game then
		local cur_jump_info = self:GetCurJumpInfo()
		show_role_id = cur_jump_info.role_id ~= 0 and cur_jump_info.role_id or RoleManager.Instance.mainRoleInfo.role_id

	else
		show_role_id = RoleManager.Instance.mainRoleInfo.role_id
		
	end
	local role_list = self:GetGameMemberInfo()
	if role_list and #role_list > 0 then
		for k,v in pairs(role_list) do	
			local role = Scene.Instance:GetRole(v.role_id)
			if role then
				role:SetModelHideFlag(SceneObj.ModelHideFlag.Story, v.role_id ~= show_role_id)
			end		
		end
	end
end

--跳一跳获取游戏状态
function JumpOneModel:GetGameState()
	local game_state = self.game_info and self.game_info.game_state  or JumpOneModel.GAME_STATE.WAIT
	return game_state
end

--跳一跳当前跳跃按下的状态
function JumpOneModel:GetJumpTouchState()
	return self.game_info.game_info and self.game_info.game_info.jump_touch_state and self.game_info.game_info.jump_touch_state or JumpOneModel.JUMP_TOUCH_STATE.NONE
end

--跳一跳当前跳跃按下的状态
function JumpOneModel:SetJumpTouchState(state)
	self.game_info.game_info = self.game_info.game_info or {}
	self.game_info.game_info.jump_touch_state = state 
end

--跳一跳离线更新
function JumpOneModel:SetOffLinePlayer(vo)
	self.game_info.off_line_info = self.game_info.off_line_info or {}
	self.game_info.off_line_info[vo.role_id] = vo
	local role_list = self:GetGameMemberInfo()
	if role_list and #role_list > 0 then
		for i,v in ipairs(role_list) do
			if v.role_id == vo.role_id then
				if v.life ~= 0 then					
					v.player_state = JumpOneModel.PLAYER_STATE.OFF_LINE
				end				
				break
			end
		end
	end
	PrintTable(self.game_info.off_line_info)
	self:Fire(JumpOneModel.JUMP_OFF_LINE_UPDATE)
end

--跳一跳上线更新
function JumpOneModel:SetOnLinePlayer(vo)
	local role_list = self:GetGameMemberInfo()
	if role_list and #role_list > 0 then
		for i,v in ipairs(role_list) do
			if v.role_id == vo.role_id then
				if v.life ~= 0 then					
					v.player_state = JumpOneModel.PLAYER_STATE.ON_LINE
				end				
				break
			end
		end
	end
	--玩家上线时，同步一次这个玩家的状态
	local main_role = Scene.Instance.main_role
	if main_role then
		local pos_x, pos_y =  main_role:GetRealPos()
		self:SyncTargetRolePos(pos_x, pos_y, vo.role_id)
	end	
	self:UpdateMemberVisible()
	local last_step_info = self:GetLastStepInfo()	
	if last_step_info then
		self:UpdateMemberDir(last_step_info.x, last_step_info.y)	
	end		
	self:Fire(JumpOneModel.JUMP_ON_LINE_UPDATE)
end

--跳一跳获取当前跳跃者的role_id
function JumpOneModel:GetCurjumperRoleId()
	local cur_jump_info = self:GetCurJumpInfo()
	local role_id = cur_jump_info and cur_jump_info.role_id or -1
	return role_id
end

--跳一跳获取当前跳跃者的role_id
function JumpOneModel:GetPlayerStateByRoleId(role_id)
	local player_state = JumpOneModel.PLAYER_STATE.ON_LINE
	local member_list = self:GetGameMemberInfo()
	if member_list and #member_list > 0 then
		for i,v in ipairs(member_list) do
			if v.role_id == role_id then
				player_state = v.player_state
			end
		end
	end
	return player_state
end


--跳一跳获取跳跃者的信息
function JumpOneModel:GetPlayerInfoRoleId(role_id)	
	local member_list = self:GetGameMemberInfo()
	if member_list and #member_list > 0 then
		for i,v in ipairs(member_list) do
			if v.role_id == role_id then
				return v
			end
		end
	end
end

--跳一跳获取玩家的命数
function JumpOneModel:GetPlayerLife(role_id)
	local life_cnt = 0
	local member_list = self:GetGameMemberInfo()
	if member_list and #member_list > 0 then
		for i,v in ipairs(member_list) do
			if v.role_id == role_id then
				life_cnt = v.life
			end
		end
	end
	return life_cnt
end

--跳一跳设置结算界面
function JumpOneModel:SetResultInfo(vo)
	self.result_info = vo
	self:Fire(JumpOneModel.JUMP_GAME_RESULT_NOTIFY)
end

--跳一跳游戏结束
function JumpOneModel:SetGameEnd(vo)
	self.game_info.game_state = JumpOneModel.GAME_STATE.END
	local time = vo.end_time - TimeUtil:getServerTime( )
	self:Fire(JumpOneModel.JUMP_GAME_END_NOTIFY, time)
end

--跳一跳获取最少匹配时间
function JumpOneModel:GetMinMatchTime()
	local time = 0
	local cfg = Config.Jumpactkv
	if cfg and cfg["jump_wait"] then
		time = cfg["jump_wait"].value_content
	end
	return time
end

--跳一跳获取最少匹配人数
function JumpOneModel:GetMinMatchNum()
	local num = 0
	local cfg = Config.Jumpactkv
	if cfg and cfg["jump_min_num"] then
		num = cfg["jump_min_num"].value_content
	end
	return num
end

--跳跃最大蓄力时间
function JumpOneModel:GetJumpMaxTouchTime()
	if not self.jump_max_touch_time then
		local cfg = Config.Jumpactkv
		if cfg and cfg["jump_max_second"] then
			self.jump_max_touch_time = cfg["jump_max_second"].value_content
			self.jump_max_touch_time = self.jump_max_touch_time * 1000
		else
			self.jump_max_touch_time = 4000
		end	
	end	
	return self.jump_max_touch_time
end


--跳一跳最大跳跃操作时间
function JumpOneModel:GetMaxJumpTime()
	if not self.max_jump_time then
		local cfg = Config.Jumpactkv
		if cfg and cfg["jump_time"] then
			self.max_jump_time = cfg["jump_time"].value_content
		else
			time = 15
		end
	end
	return self.max_jump_time	
end

--获取角色的vo信息，用于不在线的玩家
function JumpOneModel:GetRoleVoByRoleId(role_id)
	local role_list = self:GetGameMemberInfo()
	local role_vo
	if role_list and #role_list > 0 then
		for i,v in ipairs(role_list) do
			if v.role_id == role_id then
				role_vo = v
			end
		end
	end
	return role_vo
end

--获取匹配开始时间
function JumpOneModel:GetMatchReadTime()
	local time = 0
	if self.view_info.match_members and self.view_info.match_members.begin_time ~= 0 then
		 time = self.view_info.match_members.begin_time - TimeUtil:getServerTime()
	end
	return time
end

--获取活动奖励
function JumpOneModel:GetlRewardList(base_type, sub_type)
	if not self.reward_info or not self.reward_info[base_type] or not self.reward_info[base_type][sub_type] then
		self.reward_info = self.reward_info or {}
		local act_info = CustomActivityModel:getInstance():getOneActRewardList(base_type, sub_type)
		if act_info then
			local list = {}
			for i=#act_info.reward_list,1,-1 do
				local t =  stringtotable(act_info.reward_list[i].reward) 
				table.insert(list, t[1])
			end
			self.reward_info = self.reward_info or {}
			self.reward_info[base_type] = self.reward_info[base_type] or {}
			self.reward_info[base_type][sub_type] = list
		end
	end	
	return self.reward_info and self.reward_info[base_type] and self.reward_info[base_type][sub_type] or {}
end

--获取活动开放
function JumpOneModel:GetOpenTime(open_time_table, last_time_table)
	local str = ""
	if not open_time_table or not last_time_table or open_time_table == 0 or #last_time_table == 0 then return end
	for i=1,#open_time_table do
		if str ~= "" then
		 	str = str .. "\n"
		end
		local start_str = self:TimeTable2String(open_time_table[i])
		local end_time_table = 
		{
			[1] = tonumber(open_time_table[i][1]) + math.floor(tonumber(last_time_table[2]) / 3600),
			[2] = tonumber(open_time_table[i][2]) + math.floor(tonumber(last_time_table[2]) % 3600),
		}

		local end_str = self:TimeTable2String(end_time_table)
		local s = string.format("第%s场 %s ~%s", WordManager:getHanZiNumber(i), start_str, end_str)
		str = str .. s
	end
	return str 
end

--解析时间table
function JumpOneModel:TimeTable2String(time_table)
	local str = ""
	if time_table and time_table[1] and time_table[2] then			
		local h_s = tonumber(time_table[1]) > 10 and tostring(time_table[1]) or ("0" ..  tostring(time_table[1]))
		local m_s = tonumber(time_table[2]) > 10 and tostring(time_table[2]) or ("0" ..  tostring(time_table[2]))
		str = h_s .. ":" .. m_s
	end
	return str 
end

--跳跃结束延时协议操作
function JumpOneModel:SyncJumpEndScmd()
	local delay_func = function ()
		local sub_type = self:GetActSubType()
		self:Fire(JumpOneModel.REQUEST_INFO, 45909, self:GetRoomId(), 2, sub_type)
	end
	 setTimeout(delay_func,0.5)
end

--获取当前活动的场次(客户端这里只会存在一场)）
function JumpOneModel:GetActSubType()
	local sub_type = 0
	if self.act_cfg then
		for k,v in pairs(self.act_cfg) do
			sub_type = k
			break
		end
	end
	return sub_type
end