You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
894 lines
27 KiB
894 lines
27 KiB
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
|