628 lines
20 KiB
Lua
628 lines
20 KiB
Lua
local ZPPlayBackView = require('main.zipai.ZPPlayBackView')
|
|
local PlayerSelfCardInfoView = import('.PlayerSelfCardInfoView')
|
|
local PlayerCardInfoView = import('.PlayerCardInfoView')
|
|
local RunBeard_ResultView = import('.RunBeard_ResultView')
|
|
local M = {}
|
|
|
|
local Record_Event = {
|
|
Evt_OutCard = 'OutCard',
|
|
Evt_GetCard = 'GetCard',
|
|
Evt_Action = 'Action',
|
|
Evt_ThrowCard = 'ThrowCard',
|
|
Evt_AddCard = 'AddCard',
|
|
Evt_ChangePaiXing = 'ChangePaiXing',
|
|
Evt_Win = 'Win',
|
|
Evt_result = 'result'
|
|
}
|
|
|
|
local function tableSortNumber(a, b)
|
|
return a.card_code_number > b.card_code_number
|
|
end
|
|
|
|
--- Create a new
|
|
function M.new()
|
|
setmetatable(M, { __index = PlayBackView })
|
|
local self = setmetatable({}, { __index = M })
|
|
self.class = 'PlayBackView'
|
|
self:init()
|
|
|
|
return self
|
|
end
|
|
|
|
function M:InitView(url)
|
|
local room = self._room
|
|
self._gamectr = ControllerManager.GetController(GameController)
|
|
UIPackage.AddPackage('base/main_zipai/ui/Main_RunBeard')
|
|
UIPackage.AddPackage('extend/zipai/hsrunbeard/ui/Extend_Poker_HSRunBeard')
|
|
ZPPlayBackView.InitView(self, 'ui://Main_RunBeard/Main_' .. room.room_config.people_num)
|
|
UpdateBeat:Add(self.OnUpdate, self)
|
|
|
|
local user_id = DataManager.SelfUser.account_id
|
|
local json_data = Utils.LoadLocalFile(user_id .. room.game_id)
|
|
if json_data ~= nil then
|
|
local _data = json.decode(json_data)
|
|
local typeface = _data['game_typeface']
|
|
if typeface == 1 then
|
|
room.change_card_display = '2_'
|
|
else
|
|
room.change_card_display = '1_'
|
|
end
|
|
end
|
|
self._player_card_info = {}
|
|
local _player_card_info = self._player_card_info
|
|
for i = 1, room.room_config.people_num do
|
|
local tem = self._view:GetChild('player_card_info' .. i)
|
|
self._player_card_info[i] = self:NewPlayerPokerInfoView(tem, i)
|
|
end
|
|
local rightpanel = self._view:GetChild('right_panel')
|
|
self.btn_setting = rightpanel:GetChild('btn_setting')
|
|
self.btn_setting.visible = false
|
|
|
|
self.tex_time = rightpanel:GetChild('tex_time')
|
|
self.tex_time.visible = false
|
|
|
|
self.gcm_xinhao = rightpanel:GetChild('gcm_xinhao')
|
|
self.gcm_xinhao.visible = false
|
|
|
|
self.pb_batteryLevel = rightpanel:GetChild('pb_batteryLevel')
|
|
self.pb_batteryLevel.visible = false
|
|
|
|
local tex_round_item = rightpanel:GetChild('tex_round')
|
|
if tex_round_item ~= nil then
|
|
tex_round_item.text = '第 ' .. room.curren_round .. ' 局'
|
|
end
|
|
local btn_rule = rightpanel:GetChild('btn_log')
|
|
if btn_rule ~= nil then
|
|
btn_rule.onClick:Set(
|
|
function()
|
|
if self.RuleView == nil or self.RuleView._is_destroy then
|
|
self.RuleView = RoomInfoView.new(self._room)
|
|
end
|
|
self.RuleView:Show()
|
|
end
|
|
)
|
|
end
|
|
local tex_roomid = rightpanel:GetChild('tex_roomid')
|
|
tex_roomid.text = room.room_id
|
|
rightpanel:GetChild('tex_gametype').text = room.room_config:GetGameName()
|
|
|
|
self._tex_round = self._view:GetChild('tex_round')
|
|
self._tex_LeftCard = self._view:GetChild('remaining_card')
|
|
self._eventmap = {}
|
|
self._cmdmap = {}
|
|
self._cmdmap[Record_Event.Evt_OutCard] = self.CmdOutCard
|
|
self._cmdmap[Record_Event.Evt_GetCard] = self.CmdGetCard
|
|
self._cmdmap[Record_Event.Evt_Action] = self.CmdAction
|
|
self._cmdmap[Record_Event.Evt_ThrowCard] = self.CmdThrowCard
|
|
self._cmdmap[Record_Event.Evt_AddCard] = self.CmdAddCard
|
|
self._cmdmap[Record_Event.Evt_Win] = self.CmdWin
|
|
self._cmdmap[Record_Event.Evt_ChangePaiXing] = self.CmdChangePaiXing
|
|
self._cmdmap[Record_Event.Evt_result] = self.onResult
|
|
end
|
|
|
|
function M:NewPlayerPokerInfoView(view, index)
|
|
if index == 1 then
|
|
return PlayerSelfCardInfoView.new(view, self)
|
|
end
|
|
return PlayerCardInfoView.new(view, self)
|
|
end
|
|
|
|
function M:FillRoomData(data)
|
|
if self._win_pic then
|
|
self._win_pic:Dispose()
|
|
end
|
|
self._currentStep = 0
|
|
local room = DataManager.CurrenRoom
|
|
local _player_card_info = self._player_card_info
|
|
local roominfo_panel = self._view:GetChild('roominfo_panel1')
|
|
roominfo_panel:GetChild('tex_roomid').text = room.room_id
|
|
roominfo_panel:GetChild('tex_gametype').text = room.room_config:GetGameName()
|
|
for i = 1, #room.player_list do
|
|
local p = room.player_list[i]
|
|
local card_info = _player_card_info[self:GetPos(p.seat)]
|
|
card_info:Clear()
|
|
card_info:SetPlayer(p)
|
|
if p.seat == room.self_player.seat then
|
|
card_info:UpdateIsOnClick(false)
|
|
end
|
|
local infoHand = self._player_info[self:GetPos(p.seat)]
|
|
infoHand._view:GetController('huxi').selectedIndex = 1
|
|
infoHand._view:GetChild('huxi').text = p.hu_xi
|
|
if p.total_hp then
|
|
infoHand._view:GetController('zhanji').selectedIndex = 0
|
|
if room.hpOnOff == 1 or room:checkHpNonnegative() then
|
|
infoHand._view:GetController('zhanji').selectedIndex = 1
|
|
infoHand._view:GetChild('tex_jifen').text = d2ad(p.total_hp)
|
|
end
|
|
infoHand:UpdateScore()
|
|
end
|
|
end
|
|
self:UpdateRound(self._room.curren_round)
|
|
self:GenerateAllStepData(data)
|
|
self:ShowStep(1)
|
|
self:UpdateStep(1)
|
|
end
|
|
|
|
function M:ShowStep(index)
|
|
local step = self._step[index + 1]
|
|
self:UpdateStep(index + 1)
|
|
self:UpdateLeftCard(step.left_card)
|
|
for i = 1, #step.player_card_data do
|
|
local p = self._room:GetPlayerBySeat(i)
|
|
local info = self._player_card_info[self:GetPos(i)]
|
|
p.card_list = step.player_card_data[i].card_list
|
|
p.outcard_list = step.player_card_data[i].outcard_list
|
|
p.fz_list = step.player_card_data[i].fz_list
|
|
p.hu_xi = step.player_card_data[i].hu_xi
|
|
p.hand_left_count = #p.card_list
|
|
|
|
if index == 1 then
|
|
info:Clear()
|
|
if p.total_hp then
|
|
local avHand = self._player_info[self:GetPos(p.seat)]
|
|
local room = DataManager.CurrenRoom
|
|
avHand._view:GetController('zhanji').selectedIndex = 0
|
|
if room.hpOnOff == 1 or room:checkHpNonnegative() then
|
|
avHand._view:GetController('zhanji').selectedIndex = 1
|
|
avHand._view:GetChild('tex_jifen').text = d2ad(p.total_hp)
|
|
end
|
|
avHand:UpdateScore()
|
|
end
|
|
end
|
|
if p.hu_xi ~= nil then
|
|
local infoHand = self._player_info[self:GetPos(p.seat)]
|
|
infoHand._view:GetChild('huxi').text = p.hu_xi
|
|
end
|
|
if step.cmd == Record_Event.Evt_Action then
|
|
if p.fz_list ~= nil and #p.fz_list > 0 then
|
|
info:UpdateFzList(p.fz_list)
|
|
end
|
|
end
|
|
|
|
if p.seat ~= self._room.self_player.seat then
|
|
info:InitHandCard(p.card_list)
|
|
else
|
|
self._room.self_player.handcard_list = p.card_list
|
|
info:InitHandCard(false)
|
|
end
|
|
if step.cmd == Record_Event.Evt_ChangePaiXing then
|
|
local _card_list = {}
|
|
for i = 1, #step.card_list do
|
|
local data = {}
|
|
data.card_item = step.card_list[i].card
|
|
data.index_X = step.card_list[i].X
|
|
data.index_Y = step.card_list[i].Y
|
|
_card_list[#_card_list + 1] = data
|
|
end
|
|
local info = self._player_card_info[self:GetPos(step.seat)]
|
|
if step.card_list[1].card ~= nil then
|
|
info:UpdateHandCards(_card_list)
|
|
else
|
|
info:UpdateHandCards(step.card_list)
|
|
end
|
|
end
|
|
if step.cmd == Record_Event.Evt_OutCard or step.cmd == Record_Event.Evt_GetCard then
|
|
if step.DiceCard ~= nil and step.DiceCard ~= 0 then
|
|
if p.seat == step.seat then
|
|
info:UpdateOutCardList(step.DiceCard)
|
|
coroutine.start(
|
|
function()
|
|
coroutine.wait(1.5)
|
|
info:ClearOutCard()
|
|
end
|
|
)
|
|
end
|
|
end
|
|
end
|
|
if p.outcard_list ~= nil then
|
|
info:UpdateQiPai(p.outcard_list)
|
|
end
|
|
end
|
|
-- -- print("step.cmd ",step.cmdm,Record_Event.Evt_Win)
|
|
if step.cmd == Record_Event.Evt_result then
|
|
local _room = DataManager.CurrenRoom
|
|
local result = step.result
|
|
self._win_pic = UIPackage.CreateObjectFromURL('ui://Main_RunBeard/胡')
|
|
local info = self._player_card_info[self:GetPos(step.win)]
|
|
info._mask_liangpai:AddChild(self._win_pic)
|
|
self._win_pic:Center()
|
|
|
|
if result ~= nil then
|
|
if self._clearingView == nil then
|
|
self._clearingView = RunBeard_ResultView.new(self._view)
|
|
coroutine.start(
|
|
function()
|
|
coroutine.wait(0.5)
|
|
self._clearingView:Show()
|
|
end
|
|
)
|
|
end
|
|
local data = result.data.info_list
|
|
self._clearingView:InitData(
|
|
0,
|
|
_room,
|
|
result.data,
|
|
nil,
|
|
function(...)
|
|
for i = 1, #data do
|
|
local p = _room:GetPlayerBySeat(data[i].seat)
|
|
p.total_score = data[i].total_score
|
|
-- p.cur_hp = data[i]['cur_hp'] or 0
|
|
-- if data[i]['hp_info'] then
|
|
-- p.cur_hp = data[i].hp_info.cur_hp
|
|
-- end
|
|
local card_info = self._player_card_info[self:GetPos(p.seat)]
|
|
local info = self._player_info[self:GetPos(p.seat)]
|
|
card_info:Clear()
|
|
if data[i]['hp_info'] then
|
|
p.total_score = d2ad(data[i].hp_info.cur_hp)
|
|
local stotal_hp = data[i].hp_info.total_hp
|
|
info._view:GetController('zhanji').selectedIndex = 0
|
|
if _room.hpOnOff == 1 or _room:checkHpNonnegative() then
|
|
info._view:GetController('zhanji').selectedIndex = 1
|
|
info._view:GetChild('tex_jifen').text = d2ad(stotal_hp)
|
|
end
|
|
end
|
|
info:UpdateScore(p.total_score)
|
|
end
|
|
self._clearingView = nil
|
|
end
|
|
)
|
|
end
|
|
else
|
|
if self._win_pic then
|
|
self._win_pic:Dispose()
|
|
end
|
|
end
|
|
end
|
|
|
|
function M:GenerateAllStepData(data)
|
|
local cmdList = self.cmdList
|
|
self._step = {}
|
|
local step = {}
|
|
local info = data.info
|
|
step.cmd = ''
|
|
step.left_card = info.left_card
|
|
step.win = 0
|
|
|
|
step.player_card_data = {}
|
|
for i = 1, #self._room.player_list do
|
|
local p = info.playerData[i]
|
|
local u = {}
|
|
u.seat = p.seat
|
|
u.card_list = p.hand_card
|
|
u.hand_left_count = #u.card_list
|
|
u.fz_list = {}
|
|
u.outcard_list = {}
|
|
u.hu_xi = 0
|
|
step.player_card_data[u.seat] = u
|
|
end
|
|
self._step[#self._step + 1] = step
|
|
|
|
for i = 1, #cmdList do
|
|
local tem = cmdList[i]
|
|
self._cmdmap[tem.cmd](self, tem, i)
|
|
end
|
|
end
|
|
|
|
function M:CmdOutCard(cmd, index)
|
|
local data = self:CopyLastStep(index)
|
|
data.cmd = cmd.cmd
|
|
data.current_out_seat = cmd.seat
|
|
local u = data.player_card_data[cmd.seat]
|
|
list_remove(u.card_list, cmd.data.card)
|
|
data.seat = cmd.seat
|
|
data.DiceCard = cmd.data.card
|
|
end
|
|
|
|
function M:CmdGetCard(cmd, index)
|
|
local data = self:CopyLastStep(index)
|
|
data.cmd = cmd.cmd
|
|
data.left_card = cmd.data.left_count
|
|
local u = data.player_card_data[cmd.seat]
|
|
data.seat = cmd.seat
|
|
data.DiceCard = cmd.data.card
|
|
end
|
|
|
|
function M:CmdThrowCard(cmd, index)
|
|
local data = self:CopyLastStep(index)
|
|
data.cmd = cmd.cmd
|
|
data.seat = cmd.seat
|
|
data.current_seat = cmd.seat
|
|
local u = data.player_card_data[cmd.seat]
|
|
data.out_card_list = cmd.data.card
|
|
u.outcard_list[#u.outcard_list + 1] = cmd.data.card
|
|
end
|
|
|
|
function M:CmdAddCard(cmd, index)
|
|
local data = self:CopyLastStep(index)
|
|
data.cmd = cmd.cmd
|
|
local _room = self._room
|
|
local u = data.player_card_data[cmd.seat]
|
|
u.card_list[#u.card_list + 1] = cmd.data.card
|
|
end
|
|
|
|
function M:onResult(cmd, index)
|
|
local data = self:CopyLastStep(index)
|
|
data.cmd = cmd.cmd
|
|
data.result = cmd.result
|
|
end
|
|
|
|
function M:CmdChangePaiXing(cmd, index)
|
|
local data = self:CopyLastStep(index)
|
|
data.cmd = cmd.cmd
|
|
data.seat = cmd.seat
|
|
data.card_list = cmd.data.card_list
|
|
end
|
|
|
|
function M:CmdAction(cmd, index)
|
|
local data = self:CopyLastStep(index)
|
|
data.cmd = cmd.cmd
|
|
data.seat = cmd.seat
|
|
local p = data.player_card_data[cmd.seat]
|
|
local fz = {}
|
|
p.hu_xi = cmd.data.hu_xi
|
|
fz.type = cmd.data.type
|
|
fz.card = cmd.data.card
|
|
fz.active_card = cmd.data.card
|
|
fz.opcard = cmd.data.opcard
|
|
local opcard = fz.opcard
|
|
local ftype = fz.type
|
|
local card = fz.card
|
|
local remove_num = #opcard
|
|
if ftype == RB_FZType.Chi then
|
|
p.fz_list[#p.fz_list + 1] = fz
|
|
for i = 1, remove_num do
|
|
list_remove(p.card_list, opcard[i])
|
|
end
|
|
elseif ftype == RB_FZType.Bi then
|
|
p.fz_list[#p.fz_list + 1] = fz
|
|
for i = 1, remove_num do
|
|
list_remove(p.card_list, opcard[i])
|
|
end
|
|
list_remove(p.card_list, fz.card)
|
|
elseif ftype == RB_FZType.Peng then
|
|
p.fz_list[#p.fz_list + 1] = fz
|
|
for i = 1, remove_num do
|
|
list_remove(p.card_list, opcard[i])
|
|
end
|
|
elseif ftype == RB_FZType.Kan then
|
|
local _room = self._room
|
|
if #opcard == 2 then
|
|
p.card_list[#p.card_list + 1] = card
|
|
end
|
|
elseif ftype == RB_FZType.ChouWei then
|
|
p.fz_list[#p.fz_list + 1] = fz
|
|
for i = 1, 2 do
|
|
list_remove(p.card_list, opcard[i])
|
|
end
|
|
elseif ftype == RB_FZType.Wei then
|
|
p.fz_list[#p.fz_list + 1] = fz
|
|
for i = 1, remove_num do
|
|
list_remove(p.card_list, opcard[i])
|
|
end
|
|
elseif ftype == RB_FZType.Pao then
|
|
local num = 0
|
|
for i = 1, #p.card_list do
|
|
if card == p.card_list[i] then
|
|
num = num + 1
|
|
end
|
|
end
|
|
local isAddTi = false
|
|
for i = 1, #p.fz_list do
|
|
if p.fz_list[i].card == card then
|
|
p.fz_list[i].type = RB_FZType.Pao
|
|
isAddTi = true
|
|
end
|
|
end
|
|
if num > 0 then
|
|
for i = 1, num do
|
|
list_remove(p.card_list, card)
|
|
end
|
|
|
|
if isAddTi == false then
|
|
p.fz_list[#p.fz_list + 1] = fz
|
|
end
|
|
end
|
|
elseif ftype == RB_FZType.Ti then
|
|
local num = 0
|
|
for i = 1, #p.card_list do
|
|
if card == p.card_list[i] then
|
|
num = num + 1
|
|
end
|
|
end
|
|
local isAddTi = false
|
|
for i = 1, #p.fz_list do
|
|
if p.fz_list[i].card == card then
|
|
p.fz_list[i].type = RB_FZType.Ti
|
|
isAddTi = true
|
|
end
|
|
end
|
|
if num > 0 then
|
|
for i = 1, num do
|
|
list_remove(p.card_list, card)
|
|
end
|
|
|
|
if isAddTi == false then
|
|
p.fz_list[#p.fz_list + 1] = fz
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function M:CmdWin(cmd, index)
|
|
local data = self:CopyLastStep(index)
|
|
data.cmd = cmd.cmd
|
|
data.win = cmd.seat
|
|
end
|
|
|
|
function M:UpdateLeftCard(num)
|
|
self._tex_LeftCard.text = '剩余 ' .. num .. ' 张牌'
|
|
end
|
|
|
|
function M:UpdateRound(round)
|
|
self._tex_round.text = '第 ' .. round .. '/' .. self._room.room_config.round .. ' 局'
|
|
end
|
|
|
|
function M:CopyLastStep(index)
|
|
local step = {}
|
|
local last_step = self._step[index]
|
|
step = self:deepcopy(last_step)
|
|
step.player_card_data = {}
|
|
local card_data = step.player_card_data
|
|
for i = 1, #last_step.player_card_data do
|
|
card_data[i] = {}
|
|
card_data[i].card_list = self:deepcopy(last_step.player_card_data[i].card_list)
|
|
card_data[i].outcard_list = self:deepcopy(last_step.player_card_data[i].outcard_list)
|
|
card_data[i].fz_list = self:deepcopy(last_step.player_card_data[i].fz_list)
|
|
card_data[i].hand_left_count = #card_data[i].card_list
|
|
card_data[i].hu_xi = self:deepcopy(last_step.player_card_data[i].hu_xi)
|
|
end
|
|
self._step[#self._step + 1] = step
|
|
return step
|
|
end
|
|
|
|
-- lua table 深拷贝
|
|
function M:deepcopy(object)
|
|
local lookup_table = {}
|
|
local function _copy(object)
|
|
if type(object) ~= 'table' then
|
|
return object
|
|
elseif lookup_table[object] then
|
|
return lookup_table[object]
|
|
end
|
|
local new_table = {}
|
|
lookup_table[object] = new_table
|
|
for index, value in pairs(object) do
|
|
new_table[_copy(index)] = _copy(value)
|
|
end
|
|
return setmetatable(new_table, getmetatable(object))
|
|
end
|
|
return _copy(object)
|
|
end
|
|
|
|
function M:NextRecordPlay()
|
|
local result = PlayBackView.NextRecordPlay(self)
|
|
if not result then
|
|
return
|
|
end
|
|
self:ChangePlayState(false)
|
|
self._speed = 1
|
|
self._playFoward = true
|
|
self:ChangeTextSpeed()
|
|
end
|
|
|
|
function M:LastRecordPlay()
|
|
local result = PlayBackView.LastRecordPlay(self)
|
|
if not result then
|
|
return
|
|
end
|
|
self:ChangePlayState(false)
|
|
self._speed = 1
|
|
self._playFoward = true
|
|
self:ChangeTextSpeed()
|
|
end
|
|
|
|
function M:Play()
|
|
self:ChangeAlpha()
|
|
self:ChangePlayState(not self._play)
|
|
if not self._play then
|
|
return
|
|
end
|
|
if (self._currentStep == #self.cmdList and self._playFoward) or (self._currentStep == 0 and not self._playFoward) then
|
|
self._currentStep = 0
|
|
self._speed = 1
|
|
self._playFoward = true
|
|
self:ChangeTextSpeed()
|
|
end
|
|
end
|
|
|
|
function M:ChangePlayState(state)
|
|
self._play = state
|
|
self:ChangeTextSpeed()
|
|
local btn_play = self._view:GetChild('panel_record'):GetChild('btn_play')
|
|
if self._play then
|
|
btn_play:GetController('state').selectedIndex = 1
|
|
else
|
|
btn_play:GetController('state').selectedIndex = 0
|
|
end
|
|
end
|
|
|
|
function M:ChangeTextSpeed()
|
|
local str1 = self._play and self._speed or ''
|
|
self._view:GetChild('panel_record'):GetChild('tex_speed').text = str1
|
|
local str2 =
|
|
not self._play and (self._playFoward and '播放暂停' or '回退暂停') or
|
|
self._playFoward and (self._speed == 1 and '播放' or '快进') or
|
|
(self._speed == 1 and '回退' or '快退')
|
|
self._view:GetChild('panel_record'):GetChild('tex_2').text = str2
|
|
local str3 = self._play and '倍速度' or ''
|
|
self._view:GetChild('panel_record'):GetChild('tex_1').text = str3
|
|
end
|
|
|
|
function M:CmdLeftArrows()
|
|
self:ChangeAlpha()
|
|
self:ChangePlayState(true)
|
|
if not self._playFoward then
|
|
if self._speed < 16 then
|
|
self._speed = self._speed * 2
|
|
else
|
|
self._speed = 1
|
|
end
|
|
self:ChangeTextSpeed()
|
|
else
|
|
self._speed = 1
|
|
self._playFoward = false
|
|
self:ChangeTextSpeed()
|
|
end
|
|
end
|
|
|
|
function M:CmdRightArrows()
|
|
self:ChangeAlpha()
|
|
self:ChangePlayState(true)
|
|
if self._playFoward then
|
|
if self._speed < 16 then
|
|
self._speed = self._speed * 2
|
|
else
|
|
self._speed = 1
|
|
end
|
|
self:ChangeTextSpeed()
|
|
else
|
|
self._speed = 1
|
|
self._playFoward = true
|
|
self:ChangeTextSpeed()
|
|
end
|
|
end
|
|
|
|
function M:OnUpdate()
|
|
if self._play then
|
|
if (self._currentStep == #self.cmdList and self._playFoward) then
|
|
self:ChangePlayState(false)
|
|
ViewUtil.ErrorTip(nil, '当前已是录像结尾了，再次点击播放按钮可重新播放')
|
|
return
|
|
elseif (self._currentStep == 0 and not self._playFoward) then
|
|
self:ChangePlayState(false)
|
|
ViewUtil.ErrorTip(nil, '当前已是录像开头了，再次点击播放按钮可重新播放')
|
|
return
|
|
end
|
|
self._timer = self._timer + Time.deltaTime
|
|
if self._timer >= 1 / self._speed then
|
|
self._timer = 0
|
|
local step = self._playFoward and 1 or -1
|
|
self._currentStep = self._currentStep + step
|
|
self:ShowStep(self._currentStep)
|
|
end
|
|
end
|
|
end
|
|
|
|
function M:Destroy()
|
|
UpdateBeat:Remove(self.OnUpdate, self)
|
|
PlayBackView.Destroy(self)
|
|
end
|
|
|
|
function M:UpdateStep(step)
|
|
self._record:GetChild('tex_step').text = '第 ' .. step .. ' / ' .. #self._step .. '步'
|
|
end
|
|
|
|
return M
|