887 lines
23 KiB
Plaintext
887 lines
23 KiB
Plaintext
autoImport("PvpRoomData");
|
||
autoImport("YoyoRoomData");
|
||
autoImport("MvpBattleTeamData")
|
||
autoImport("TeamPwsData")
|
||
|
||
PvpProxy = class('PvpProxy', pm.Proxy)
|
||
PvpProxy.Instance = nil;
|
||
PvpProxy.NAME = "PvpProxy"
|
||
|
||
PvpProxy.Type = {
|
||
Yoyo = MatchCCmd_pb.EPVPTYPE_LLH, --溜溜猴
|
||
DesertWolf = MatchCCmd_pb.EPVPTYPE_SMZL, --沙漠之狼
|
||
GorgeousMetal = MatchCCmd_pb.EPVPTYPE_HLJS, --華麗金屬
|
||
PoringFight = MatchCCmd_pb.EPVPTYPE_POLLY, --波利大亂鬥
|
||
MvpFight = MatchCCmd_pb.EPVPTYPE_MVP or MatchCCmd_pb.EPVPTYPE_POLLY, --波利大亂鬥
|
||
SuGVG = MatchCCmd_pb.EPVPTYPE_SUGVG,
|
||
TutorMatch = MatchCCmd_pb.EPVPTYPE_TUTOR, -- 導師匹配借用
|
||
TeamPws = MatchCCmd_pb.EPVPTYPE_TEAMPWS, -- 組隊排位賽
|
||
FreeBattle = MatchCCmd_pb.EPVPTYPE_TEAMPWS_RELAX, -- 休閑賽
|
||
}
|
||
|
||
PvpProxy.RoomStatus = {
|
||
WaitJoin = MatchCCmd_pb.EROOMSTATE_WAIT_JOIN,
|
||
ReadyForFight = MatchCCmd_pb.EROOMSTATE_READY_FOR_FIGHT,
|
||
Fighting = MatchCCmd_pb.EROOMSTATE_FIGHTING,
|
||
Success = MatchCCmd_pb.EROOMSTATE_MATCH_SUCCESS,
|
||
End = MatchCCmd_pb.EROOMSTATE_END,
|
||
}
|
||
|
||
-- 組隊競技戰 顏色列舉
|
||
PvpProxy.TeamPws = {
|
||
TeamColor = {
|
||
Red = FuBenCmd_pb.ETEAMPWS_RED,
|
||
Blue = FuBenCmd_pb.ETEAMPWS_BLUE,
|
||
}
|
||
}
|
||
|
||
function PvpProxy:ctor(proxyName, data)
|
||
self.proxyName = proxyName or PvpProxy.NAME
|
||
if(PvpProxy.Instance == nil) then
|
||
PvpProxy.Instance = self
|
||
end
|
||
if data ~= nil then
|
||
self:setData(data)
|
||
end
|
||
|
||
self:Init()
|
||
end
|
||
|
||
function PvpProxy:Init()
|
||
self.pvpStatusMap = {};
|
||
|
||
self.roomListMap = {};
|
||
self.detail_roomid_map = {};
|
||
|
||
self.server_teamPwsInfo = {};
|
||
|
||
--追蹤資訊
|
||
self.fightStatInfo = {}
|
||
self.fightStatInfo.ranks = {}
|
||
self:ClearBosses()
|
||
end
|
||
|
||
function PvpProxy:ClearBosses()
|
||
self.bosses = {}
|
||
end
|
||
|
||
function PvpProxy:ResetMyRoomInfo()
|
||
if(self.myRoomData)then
|
||
self.myRoomData = nil;
|
||
end
|
||
end
|
||
|
||
function PvpProxy:SetMyRoomBriefInfo(type, brief_info)
|
||
-- local myRoomType = PvpProxy.Instance:GetMyRoomType()
|
||
-- if(myRoomType and myRoomType~=type)then
|
||
-- return
|
||
-- end
|
||
|
||
if(brief_info == nil or brief_info.type == nil)then
|
||
redlog("PvpProxy-->ReSetMyRoomBriefInfo",brief_info.roomid);
|
||
self:ResetMyRoomInfo();
|
||
else
|
||
local roomid = brief_info.roomid;
|
||
redlog("PvpProxy-->SetMyRoomBriefInfo", string.format("reqType:%s Roomid:%s Type:%s State:%s", type, roomid,brief_info.type, brief_info.state));
|
||
self.myRoomData = PvpRoomData.new(roomid);
|
||
self.myRoomData:SetData(brief_info);
|
||
|
||
local roomlist = self:GetRoomList(type);
|
||
if(roomlist)then
|
||
local find = false
|
||
for i=1,#roomlist do
|
||
if(roomlist[i].guid == roomid)then
|
||
roomlist[i]:SetData(brief_info);
|
||
find = true
|
||
break;
|
||
end
|
||
end
|
||
if(not find) then
|
||
if(type==PvpProxy.Type.DesertWolf)then
|
||
local myRoom = PvpRoomData.new(roomid);
|
||
myRoom:SetData(brief_info);
|
||
roomlist[#roomlist+1] = myRoom
|
||
table.sort(roomlist, function (l,r)
|
||
return self:SortDesertRoomData(l,r)
|
||
end )
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
end
|
||
|
||
function PvpProxy:UpdateMyRoomStatus(pvp_type, roomid, state, endtime)
|
||
if(self.myRoomData and self.myRoomData.guid == roomid)then
|
||
redlog("PvpProxy-->UpdateMyRoomStatus", string.format("Type:%s Roomid:%s State:%s", pvp_type, roomid, state));
|
||
self.myRoomData.state = state;
|
||
self.myRoomData:SetEndTime(endtime);
|
||
end
|
||
end
|
||
|
||
function PvpProxy:GetMyRoomType()
|
||
if(self.myRoomData)then
|
||
return self.myRoomData.type;
|
||
end
|
||
end
|
||
|
||
function PvpProxy:GetMyRoomState(type)
|
||
if(self.myRoomData and self.myRoomData.type == type)then
|
||
return self.myRoomData.state;
|
||
end
|
||
return PvpProxy.RoomStatus.WaitJoin;
|
||
end
|
||
|
||
|
||
function PvpProxy:GetMyRoomGuid()
|
||
if(self.myRoomData)then
|
||
return self.myRoomData.roomid;
|
||
end
|
||
end
|
||
|
||
|
||
function PvpProxy:SetRoomList(type, room_lists)
|
||
local detailRoomData = nil;
|
||
local detail_roomid = self.detail_roomid_map[type];
|
||
if(detail_roomid)then
|
||
detailRoomData = self:GetRoomData(type, detail_roomid);
|
||
end
|
||
helplog("SetRoomList", type, detail_roomid, detailRoomData);
|
||
local roomlist = {};
|
||
|
||
local roomids = "";
|
||
for i=1,#room_lists do
|
||
local list = room_lists[i];
|
||
roomids = roomids .. " " .. list.roomid;
|
||
if(detailRoomData and list.roomid == detailRoomData.guid)then
|
||
detailRoomData:SetData(list);
|
||
detailRoomData:SetIndex(i);
|
||
table.insert(roomlist, detailRoomData);
|
||
else
|
||
local roomdata = PvpRoomData.new(list.roomid);
|
||
roomdata:SetData(list);
|
||
roomdata:SetIndex(i);
|
||
table.insert(roomlist, roomdata);
|
||
end
|
||
end
|
||
if(type==PvpProxy.Type.DesertWolf)then
|
||
table.sort(roomlist, function (l,r)
|
||
return self:SortDesertRoomData(l,r)
|
||
end )
|
||
end
|
||
self.roomListMap[type] = roomlist;
|
||
end
|
||
|
||
function PvpProxy:SetYoyoRoomList(type,roomList)
|
||
local yoyoRoomData=YoyoRoomData.new();
|
||
yoyoRoomData:SetData(roomList);
|
||
self.roomListMap[type]=yoyoRoomData:GetyoyoRoomData();
|
||
end
|
||
|
||
function PvpProxy:SortDesertRoomData(l,r)
|
||
if(l.roomid==self:GetMyRoomGuid())then
|
||
return true
|
||
elseif(r.roomid==self:GetMyRoomGuid())then
|
||
return false
|
||
else
|
||
return l.roomid<r.roomid
|
||
end
|
||
end
|
||
|
||
|
||
function PvpProxy:GetRoomList(type)
|
||
local roomlist = self.roomListMap[type];
|
||
if(roomlist)then
|
||
if(type == PvpProxy.Type.GorgeousMetal)then
|
||
if(self.gorgeousMetal_SortFunc == nil)then
|
||
self.gorgeousMetal_SortFunc = function(a, b)
|
||
local ina = false;
|
||
local inb = false;
|
||
if(self.myRoomData ~= nil and self.myRoomData.type == type)then
|
||
ina = a.guid == self.myRoomData.guid;
|
||
inb = b.guid == self.myRoomData.guid;
|
||
end
|
||
if(ina ~= inb)then
|
||
return ina == true;
|
||
end
|
||
return a.index < b.index;
|
||
end
|
||
end
|
||
table.sort(roomlist, self.gorgeousMetal_SortFunc);
|
||
end
|
||
return roomlist;
|
||
end
|
||
end
|
||
|
||
function PvpProxy:GetRoomData(type, guid)
|
||
local roomlist = self.roomListMap[type];
|
||
local roomData = nil;
|
||
if(roomlist)then
|
||
for i=1,#roomlist do
|
||
if(roomlist[i].guid == guid)then
|
||
roomData = roomlist[i];
|
||
break;
|
||
end
|
||
end
|
||
end
|
||
return roomData;
|
||
end
|
||
|
||
function PvpProxy:SetRoomDetailInfo(type, guid, detail_info)
|
||
if(type == nil)then
|
||
return;
|
||
end
|
||
|
||
local roomData = self:GetRoomData(type, guid);
|
||
|
||
if(roomData)then
|
||
roomData:SetRoomDetailInfo(detail_info);
|
||
else
|
||
helplog("Not Find RoomData:" .. tostring(guid));
|
||
end
|
||
|
||
self.detail_roomid_map[type] = guid;
|
||
end
|
||
|
||
-- function PvpProxy:TestRoomBriefInfo()
|
||
-- local testRoomData = {};
|
||
-- for i=1,20 do
|
||
-- local roombriefInfo = {};
|
||
-- roombriefInfo.guid = 10000 + i;
|
||
-- roombriefInfo.name = "華麗金屬房間" .. i
|
||
-- roombriefInfo.player_num = math.random(3,5);
|
||
-- roombriefInfo.num1 = 0;
|
||
-- roombriefInfo.num2 = 2;
|
||
-- roombriefInfo.num3 = 0;
|
||
-- table.insert(testRoomData, roombriefInfo);
|
||
-- end
|
||
-- self:SetRoomList(PvpProxy.Type.GorgeousMetal, testRoomData);
|
||
|
||
-- local reqRoomData =
|
||
-- {
|
||
-- type = PvpProxy.Type.GorgeousMetal,
|
||
-- };
|
||
-- self:sendNotification(ServiceEvent.MatchCCmdReqRoomListCCmd, reqRoomData);
|
||
-- end
|
||
|
||
|
||
|
||
-- function PvpProxy:TestYoyoRoom()
|
||
-- local testRoomData = {};
|
||
-- for i=1,60 do
|
||
-- local roombriefInfo = {};
|
||
-- roombriefInfo.roomid = i;
|
||
-- roombriefInfo.name = "溜溜猴房間" .. i
|
||
-- roombriefInfo.player_num = math.random(15,20);
|
||
-- table.insert(testRoomData, roombriefInfo);
|
||
-- end
|
||
-- self:SetRoomList(PvpProxy.Type.Yoyo, testRoomData);
|
||
-- end
|
||
|
||
|
||
function PvpProxy:GetFightStatInfo( )
|
||
-- body
|
||
return self.fightStatInfo
|
||
end
|
||
|
||
function PvpProxy:RecvNtfRankChangeCCmd(data)
|
||
local ranks = data.ranks
|
||
local rankDatas = {}
|
||
for i=1,#ranks do
|
||
local tb = {}
|
||
tb.name = ranks[i].name
|
||
tb.apple = ranks[i].apple
|
||
rankDatas[#rankDatas+1] = tb
|
||
end
|
||
|
||
self.fightStatInfo.ranks = rankDatas
|
||
end
|
||
|
||
function PvpProxy:NtfFightStatCCmd(data)
|
||
self.fightStatInfo.pvp_type = data.pvp_type
|
||
self.fightStatInfo.starttime = data.starttime
|
||
self.fightStatInfo.player_num = data.player_num
|
||
self.fightStatInfo.score = data.score
|
||
self.fightStatInfo.my_teamscore = data.my_teamscore
|
||
self.fightStatInfo.enemy_teamscore = data.enemy_teamscore
|
||
self.fightStatInfo.remain_hp = data.remain_hp
|
||
if(data.myrank == 9999)then
|
||
self.fightStatInfo.myrank = nil
|
||
else
|
||
self.fightStatInfo.myrank = data.myrank
|
||
end
|
||
end
|
||
|
||
function PvpProxy:HandlePvpResult(result)
|
||
local data = {}
|
||
data.result = result
|
||
self:sendNotification(UIEvent.JumpPanel, {view = PanelConfig.UIVictoryView, viewdata = data})
|
||
end
|
||
|
||
function PvpProxy:IsSelfInPvp()
|
||
local mapid = Game.MapManager:GetMapID()
|
||
if mapid then
|
||
local mapRaid = Table_MapRaid[mapid]
|
||
if mapRaid then
|
||
if mapRaid.Type == FunctionDungen.YoyoType or
|
||
mapRaid.Type == FunctionDungen.DesertWolfType or
|
||
mapRaid.Type == FunctionDungen.GorgeousMetalType then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
return false
|
||
end
|
||
|
||
function PvpProxy:IsSelfInGuildBase()
|
||
return Game.MapManager:GetMapID() == 10001 or DojoProxy.Instance:IsSelfInDojo()
|
||
end
|
||
|
||
function PvpProxy:RecvSyncMvpInfoFubenCmd(initInfo)
|
||
self:ClearBosses()
|
||
self.usernum = initInfo.usernum
|
||
local liveBosses = initInfo.liveboss
|
||
local deadBosses = initInfo.dieboss
|
||
for i=1,#liveBosses do
|
||
local single = liveBosses[i]
|
||
local data = self.bosses[single]
|
||
if(not data)then
|
||
data = {live = 1,total = 1}
|
||
self.bosses[single] = data
|
||
else
|
||
data.live = data.live + 1
|
||
data.total = data.total + 1
|
||
end
|
||
end
|
||
|
||
for i=1,#deadBosses do
|
||
local single = deadBosses[i]
|
||
local data = self.bosses[single]
|
||
if(not data)then
|
||
data = {live = 0,total = 1}
|
||
self.bosses[single] = data
|
||
else
|
||
data.total = data.total + 1
|
||
end
|
||
end
|
||
|
||
end
|
||
|
||
local function SortMvpResult(l, r)
|
||
local lMvpCount = l:GetKillMvpCount()
|
||
local rMvpCount = r:GetKillMvpCount()
|
||
if lMvpCount == rMvpCount then
|
||
local lMiniCount = l:GetKillMiniCount()
|
||
local rMiniCount = r:GetKillMiniCount()
|
||
if lMiniCount == rMiniCount then
|
||
return l.teamid < r.teamid
|
||
else
|
||
return lMiniCount > rMiniCount
|
||
end
|
||
else
|
||
return lMvpCount > rMvpCount
|
||
end
|
||
end
|
||
|
||
function PvpProxy:RecvMvpBattleReportFubenCmd(data)
|
||
if self.mvpResultList == nil then
|
||
self.mvpResultList = {}
|
||
else
|
||
TableUtility.ArrayClear(self.mvpResultList)
|
||
end
|
||
|
||
for i=1,#data.datas do
|
||
local mvpData = MvpBattleTeamData.new(data.datas[i])
|
||
self.mvpResultList[#self.mvpResultList + 1] = mvpData
|
||
end
|
||
|
||
table.sort(self.mvpResultList, SortMvpResult)
|
||
end
|
||
|
||
function PvpProxy:RecvUpdateUserNumFubenCmd(data)
|
||
self.usernum = data.usernum
|
||
end
|
||
|
||
function PvpProxy:RecvBossDieFubenCmd(data)
|
||
local data = self.bosses[data.npcid]
|
||
if(not data)then
|
||
data = {live = 0,total = 1}
|
||
self.bosses[data.npcid] = data
|
||
else
|
||
local live = data.live
|
||
if(live and live >0)then
|
||
data.live = data.live - 1
|
||
else
|
||
data.live = 0
|
||
end
|
||
end
|
||
end
|
||
|
||
function PvpProxy:PvpTeamMemberUpdateCCmd(matchTeamMemUpdateInfo)
|
||
if(matchTeamMemUpdateInfo == nil)then
|
||
return;
|
||
end
|
||
|
||
local roomid = matchTeamMemUpdateInfo.roomid;
|
||
local teamid = matchTeamMemUpdateInfo.teamid;
|
||
local isfirst = matchTeamMemUpdateInfo.isfirst;
|
||
local index =matchTeamMemUpdateInfo.index;
|
||
|
||
if(roomid and teamid)then
|
||
local roomData = self:GetRoomData(PvpProxy.Type.GorgeousMetal, roomid);
|
||
if(roomData)then
|
||
local teamData = roomData:GetRoomTeamDataByPos(index);
|
||
if(teamData)then
|
||
teamData.id = teamid;
|
||
teamData.roomid = roomid;
|
||
teamData.zoneid = zoneid;
|
||
|
||
local updates = matchTeamMemUpdateInfo.updates;
|
||
if(updates)then
|
||
teamData:SetMembers(updates);
|
||
end
|
||
local deletes = matchTeamMemUpdateInfo.deletes;
|
||
if(deletes)then
|
||
teamData:RemoveMembers(deletes);
|
||
end
|
||
|
||
local myTeam = TeamProxy.Instance.myTeam;
|
||
if(myTeam == nil or (myTeam.id == teamData.id and teamData.memberNum == 0))then
|
||
self:ResetMyRoomInfo();
|
||
end
|
||
else
|
||
redlog("PVP: Pos Is illegal", index, tostring(teamData));
|
||
end
|
||
end
|
||
end
|
||
|
||
local myID = Game.Myself.data.id
|
||
local deletesId = matchTeamMemUpdateInfo.deletes;
|
||
for _,v in pairs(deletesId) do
|
||
if(v==myID)then
|
||
self:ResetMyRoomInfo()
|
||
break
|
||
end
|
||
end
|
||
end
|
||
|
||
function PvpProxy:PvpMemberDataUpdate(matchTeamMemDataUpdateInfo)
|
||
if(matchTeamMemDataUpdateInfo == nil)then
|
||
return;
|
||
end
|
||
|
||
local roomid = matchTeamMemDataUpdateInfo.roomid;
|
||
local teamid = matchTeamMemDataUpdateInfo.teamid;
|
||
local charid = matchTeamMemDataUpdateInfo.charid;
|
||
local members = matchTeamMemDataUpdateInfo.members;
|
||
|
||
if(roomid and teamid and charid and members)then
|
||
local roomData = self:GetRoomData(PvpProxy.Type.GorgeousMetal, roomid);
|
||
if(roomData)then
|
||
local teamData = roomData:GetTeamByGuid(teamid);
|
||
if(teamData)then
|
||
local teamMemberData = teamData:GetMemberByGuid(charid);
|
||
if(teamMemberData)then
|
||
teamMemberData:SetMemberData(members);
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function PvpProxy:DoKickTeamCCmd(type, roomid, zoneid, teamid)
|
||
local roomList = self:GetRoomList(type);
|
||
if(roomList)then
|
||
for i=1,#roomList do
|
||
local roomData = roomList[i];
|
||
if(roomData and roomData.guid == roomid)then
|
||
roomData:RemoveTeamByGuid(teamid);
|
||
end
|
||
end
|
||
end
|
||
if(self.myRoomData and self.myRoomData.guid == roomid)then
|
||
local myTeam = TeamProxy.Instance.myTeam;
|
||
if(myTeam and myTeam.id == teamid)then
|
||
-- helplog("kick 時清空自己房間，myRoomID ",self.myRoomData.guid)
|
||
self:ResetMyRoomInfo();
|
||
end
|
||
end
|
||
if(type==PvpProxy.Type.DesertWolf)then
|
||
ServiceMatchCCmdProxy.Instance:CallReqRoomDetailCCmd(type, roomid)
|
||
end
|
||
end
|
||
|
||
function PvpProxy:Req_Server_MyRoomMatchCCmd()
|
||
if(not self.reqMyRoom)then
|
||
self.reqMyRoom = true;
|
||
ServiceMatchCCmdProxy.Instance:CallReqMyRoomMatchCCmd();
|
||
end
|
||
end
|
||
|
||
function PvpProxy:PoringFightResult(server_rank, server_rewards, server_apple)
|
||
if(server_rank == nil)then
|
||
return;
|
||
end
|
||
|
||
self.poringFight_viewdata = {};
|
||
self.poringFight_viewdata.rank = {};
|
||
|
||
local myRank = 1;
|
||
local myCharid = Game.Myself.data.id;
|
||
local poringList = GameConfig.PoliFire and GameConfig.PoliFire.trans_buffid;
|
||
|
||
local npclist = {};
|
||
for i=1,#server_rank do
|
||
local info = {};
|
||
info.charid = server_rank[i].charid;
|
||
info.index = server_rank[i].index;
|
||
info.rank = server_rank[i].rank;
|
||
info.name = server_rank[i].name;
|
||
table.insert(self.poringFight_viewdata.rank, info);
|
||
|
||
if(info.charid == myCharid)then
|
||
myRank = info.rank;
|
||
end
|
||
local listdata = {};
|
||
listdata.npcid = poringList and poringList[info.index].monster or 10001;
|
||
listdata.name = info.name;
|
||
npclist[info.rank] = listdata;
|
||
end
|
||
|
||
self.poringFight_viewdata.myRank = myRank or 1;
|
||
|
||
if(server_rewards)then
|
||
self.poringFight_viewdata.rewards = {};
|
||
for i=1,#server_rewards do
|
||
local reward = server_rewards[i];
|
||
local item = ItemData.new(nil, reward.itemid);
|
||
item.num = reward.count;
|
||
table.insert(self.poringFight_viewdata.rewards, item)
|
||
end
|
||
end
|
||
|
||
self.poringFight_viewdata.apple = server_apple;
|
||
|
||
if(myRank == 9999)then
|
||
GameFacade.Instance:sendNotification(UIEvent.JumpPanel, {view = PanelConfig.PoringFightResultView});
|
||
else
|
||
Game.PlotStoryManager:Start(1, nil, nil, PlotConfig_Prefix.Anim, npclist);
|
||
end
|
||
end
|
||
|
||
function PvpProxy:GetPoringFight_viewdata()
|
||
return self.poringFight_viewdata;
|
||
end
|
||
|
||
function PvpProxy:NtfMatchInfo(etype, ismatch, isfighting)
|
||
if(etype == nil)then
|
||
return;
|
||
end
|
||
if(self.matchStateMap == nil)then
|
||
self.matchStateMap = {};
|
||
end
|
||
self.matchStateMap[etype] = {}
|
||
self.matchStateMap[etype].ismatch = ismatch;
|
||
self.matchStateMap[etype].isfighting = isfighting
|
||
self.matchStateMap[etype].startMatchTime = ismatch and ServerTime.CurServerTime() or nil
|
||
if (etype == PvpProxy.Type.TeamPws or etype == PvpProxy.Type.FreeBattle) then
|
||
if (not ismatch) then
|
||
self:ClearTeamPwsPreInfo()
|
||
end
|
||
self.matchStateMap[etype].isprepare = false
|
||
end
|
||
|
||
self.latestEtype = etype
|
||
self.latestMatchInfo = self.matchStateMap[etype]
|
||
end
|
||
|
||
function PvpProxy:GetStartMatchTime(etype)
|
||
if(self.matchStateMap == nil)then
|
||
return nil;
|
||
end
|
||
return self.matchStateMap[etype].startMatchTime
|
||
end
|
||
|
||
function PvpProxy:GetMatchState(etype)
|
||
if(self.matchStateMap == nil)then
|
||
return nil;
|
||
end
|
||
return self.matchStateMap[etype];
|
||
end
|
||
|
||
function PvpProxy:GetNowMatchInfo()
|
||
return self.latestEtype, self.latestMatchInfo
|
||
end
|
||
|
||
function PvpProxy:Is_polly_match()
|
||
local matchStatus = self:GetMatchState(PvpProxy.Type.MvpFight);
|
||
if(matchStatus == nil)then
|
||
return false;
|
||
end
|
||
return matchStatus.ismatch;
|
||
end
|
||
|
||
function PvpProxy:ClearMatchInfo()
|
||
if(self.matchStateMap == nil)then
|
||
return;
|
||
end
|
||
TableUtility.TableClear(self.matchStateMap);
|
||
self.latestEtype = nil;
|
||
self.latestMatchInfo = nil;
|
||
end
|
||
|
||
function PvpProxy:RecvGodEndTime(endtime)
|
||
self.godendtime = endtime;
|
||
end
|
||
|
||
function PvpProxy:GetGodEndTime()
|
||
return self.godendtime;
|
||
end
|
||
|
||
function PvpProxy:GetMvpResult()
|
||
return self.mvpResultList
|
||
end
|
||
|
||
-- TeamPws and FreeBattle Prepare Info Begin
|
||
function PvpProxy:RecvTeamPwsPreInfoMatchCCmd(serverData)
|
||
self:ClearTeamPwsPreInfo()
|
||
if (not self.matchStateMap) then
|
||
self.matchStateMap = {}
|
||
end
|
||
if (not self.matchStateMap[serverData.etype]) then
|
||
self.matchStateMap[serverData.etype] = {ismatch = true, isfighting = false}
|
||
end
|
||
self.matchStateMap[serverData.etype].isprepare = true
|
||
self.teamPwsPreInfo = ReusableTable.CreateTable()
|
||
self.teamPwsPreInfo.type = serverData.etype
|
||
for i = 1, #serverData.teaminfos do
|
||
local list, isMyTeam = self:ProcessPreInfo(serverData.teaminfos[i].charids)
|
||
if (isMyTeam) then
|
||
if (self.teamPwsPreInfo.myTeam) then
|
||
LogUtility.Error("排位賽/休閑賽準備數據出錯！")
|
||
self:ClearTeamPwsPreInfo()
|
||
self.teamPwsPreInfo = ReusableTable.CreateTable()
|
||
end
|
||
self.teamPwsPreInfo.myTeam = list
|
||
else
|
||
if (self.teamPwsPreInfo.enemyTeam) then
|
||
LogUtility.Error("排位賽/休閑賽準備數據出錯！")
|
||
self:ClearTeamPwsPreInfo()
|
||
self.teamPwsPreInfo = ReusableTable.CreateTable()
|
||
end
|
||
self.teamPwsPreInfo.enemyTeam = list
|
||
end
|
||
end
|
||
self.teamPwsPreStartTime = ServerTime.CurServerTime()
|
||
if (not TeamPwsPreparePopUp) then autoImport("TeamPwsPreparePopUp") end
|
||
TeamPwsPreparePopUp.Show(serverData.etype)
|
||
end
|
||
|
||
function PvpProxy:ProcessPreInfo(datas)
|
||
local isMyTeam = false
|
||
local list = ReusableTable.CreateArray()
|
||
local preData
|
||
for i = 1, #datas do
|
||
preData = ReusableTable.CreateTable()
|
||
list[#list + 1] = TeamPwsData.ParsePrepareData(preData, datas[i])
|
||
if (preData.charID == Game.Myself.data.id) then
|
||
isMyTeam = true
|
||
end
|
||
end
|
||
return list, isMyTeam
|
||
end
|
||
|
||
function PvpProxy:GetTeamPwsPreStartTime()
|
||
return self.teamPwsPreStartTime -- TeamPws and FreeBattle
|
||
end
|
||
|
||
function PvpProxy:RecvUpdatePreInfoMatchCCmd(serverData)
|
||
if (not self.teamPwsPreInfo or self.teamPwsPreInfo.type ~= serverData.etype and serverData.etype ~= 0) then
|
||
LogUtility.Error(string.format("排位賽/休閑賽準備數據出錯！本地型別: %s, 伺服器型別: %s", self.teamPwsPreInfo.type, serverData.etype))
|
||
return
|
||
end
|
||
local charID = serverData.charid
|
||
local datas = self.teamPwsPreInfo.myTeam
|
||
local found = false
|
||
for i = 1, #datas do
|
||
if (datas[i].charID == charID) then
|
||
datas[i].isReady = true
|
||
found = true
|
||
break
|
||
end
|
||
end
|
||
if (not found) then
|
||
datas = self.teamPwsPreInfo.enemyTeam
|
||
for i = 1, #datas do
|
||
if (datas[i].charID == charID) then
|
||
datas[i].isReady = true
|
||
break
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function PvpProxy:GetTeamPwsPreInfo()
|
||
return self.teamPwsPreInfo -- TeamPws and FreeBattle
|
||
end
|
||
|
||
function PvpProxy:ClearTeamPwsPreInfo()
|
||
if (not self.teamPwsPreInfo) then return end
|
||
if (self.teamPwsPreInfo.myTeam) then
|
||
for i = 1, #self.teamPwsPreInfo.myTeam do
|
||
ReusableTable.DestroyAndClearTable(self.teamPwsPreInfo.myTeam[i])
|
||
end
|
||
ReusableTable.DestroyAndClearArray(self.teamPwsPreInfo.myTeam)
|
||
end
|
||
if (self.teamPwsPreInfo.enemyTeam) then
|
||
for i = 1, #self.teamPwsPreInfo.enemyTeam do
|
||
ReusableTable.DestroyAndClearTable(self.teamPwsPreInfo.enemyTeam[i])
|
||
end
|
||
ReusableTable.DestroyAndClearArray(self.teamPwsPreInfo.enemyTeam)
|
||
end
|
||
ReusableTable.DestroyAndClearTable(self.teamPwsPreInfo)
|
||
self.teamPwsPreInfo = nil
|
||
end
|
||
|
||
function PvpProxy:ClearTeamPwsMatchInfo()
|
||
if (not self.matchStateMap) then return end
|
||
if (self.matchStateMap[PvpProxy.Type.TeamPws]) then
|
||
TableUtility.TableClear(self.matchStateMap[PvpProxy.Type.TeamPws])
|
||
end
|
||
if (self.matchStateMap[PvpProxy.Type.FreeBattle]) then
|
||
TableUtility.TableClear(self.matchStateMap[PvpProxy.Type.FreeBattle])
|
||
end
|
||
end
|
||
-- TeamPws and FreeBattle Prepare Info End
|
||
|
||
-- TeamPws Report Info Begin
|
||
function PvpProxy:RecvQueryTeamPwsUserInfoFubenCmd(serverData)
|
||
self:CreateTeamPwsReportData(serverData.teaminfo)
|
||
end
|
||
|
||
function PvpProxy:RecvTeamPwsReportFubenCmd(serverData)
|
||
self:CreateTeamPwsReportData(serverData.teaminfo, serverData.mvpuserinfo.charid)
|
||
local data = {winTeamColor = serverData.winteam, mvpUserInfo = serverData.mvpuserinfo}
|
||
GameFacade.Instance:sendNotification(UIEvent.JumpPanel, {view = PanelConfig.TeamPwsFightResultPopUp, viewdata = data})
|
||
end
|
||
|
||
function PvpProxy:CreateTeamPwsReportData(serverTeamInfos, mvpID)
|
||
self:ClearTeamPwsReportData()
|
||
self.teamPwsReportMap = ReusableTable.CreateArray()
|
||
local teamInfo, teamID, color, userInfos, data
|
||
for i = 1, #serverTeamInfos do
|
||
teamInfo = serverTeamInfos[i]
|
||
teamID = teamInfo.teamid
|
||
color = teamInfo.color
|
||
userInfos = teamInfo.userinfos
|
||
for i = 1, #userInfos do
|
||
data = TeamPwsData.ParseReportData(ReusableTable.CreateTable(), userInfos[i], teamID, color)
|
||
if (mvpID and mvpID == data.charID) then data.isMvp = true end
|
||
self.teamPwsReportMap[#self.teamPwsReportMap + 1] = data
|
||
end
|
||
end
|
||
end
|
||
|
||
function PvpProxy:GetTeamPwsReportData()
|
||
return self.teamPwsReportMap
|
||
end
|
||
|
||
function PvpProxy:ClearTeamPwsReportData()
|
||
if (self.teamPwsReportMap) then
|
||
for i = 1, #self.teamPwsReportMap do
|
||
ReusableTable.DestroyAndClearTable(self.teamPwsReportMap[i])
|
||
end
|
||
ReusableTable.DestroyAndClearArray(self.teamPwsReportMap)
|
||
self.teamPwsReportMap = nil
|
||
end
|
||
end
|
||
-- TeamPws Report Info End
|
||
|
||
-- 組隊競技戰 副本資訊 begin
|
||
function PvpProxy:UpdateTeamPwsInfos(syncdata, sparetime)
|
||
local mt = self.server_teamPwsInfo;
|
||
if(mt == nil)then
|
||
mt = {}
|
||
self.server_teamPwsInfo = mt;
|
||
end
|
||
|
||
if(syncdata)then
|
||
local sd, d;
|
||
|
||
local ballDirty = false;
|
||
for i=1,#syncdata do
|
||
sd = syncdata[i];
|
||
d = mt[sd.color];
|
||
if(d == nil)then
|
||
d = {};
|
||
mt[sd.color] = d;
|
||
end
|
||
|
||
d.teamid = sd.teamid;
|
||
d.teamname = sd.teamname;
|
||
d.color = sd.color;
|
||
d.score = sd.score;
|
||
|
||
local oldballs = d.balls;
|
||
if(not ballDirty and oldballs == nil)then
|
||
ballDirty = true;
|
||
end
|
||
|
||
d.balls = {};
|
||
for i=1,#sd.balls do
|
||
local id = sd.balls[i];
|
||
d.balls[id] = 1;
|
||
|
||
if(not ballDirty and not oldballs[id])then
|
||
ballDirty = true;
|
||
end
|
||
end
|
||
|
||
if(not ballDirty)then
|
||
ballDirty = next(oldballs) ~= nil;
|
||
end
|
||
|
||
-- helplog(string.format("TeamPws UpdateTeamPwsInfos. TeamId:%s | teamname:%s | color:%s | avescore:%s | effectcd:%s",
|
||
-- tostring(sd.teamid),
|
||
-- tostring(sd.teamname),
|
||
-- tostring(sd.color),
|
||
-- tostring(sd.score),
|
||
-- tostring(sd.effectcd)));
|
||
end
|
||
|
||
for i=1,#syncdata do
|
||
sd = syncdata[i];
|
||
for k,v in pairs(mt)do
|
||
if(k ~= sd.color)then
|
||
v.effectcd = sd.effectcd;
|
||
v.effectid = sd.magicid;
|
||
end
|
||
end
|
||
end
|
||
|
||
if(ballDirty)then
|
||
GameFacade.Instance:sendNotification(PVPEvent.TeamPws_PlayerBuffBallChange);
|
||
end
|
||
end
|
||
if(sparetime)then
|
||
-- helplog("UpdateTeamPwsInfos sparetime:", os.date(DATA_FORMAT, sparetime));
|
||
self.sparetime = sparetime;
|
||
end
|
||
end
|
||
|
||
function PvpProxy:GetTeamPwsInfo(color)
|
||
return self.server_teamPwsInfo[color];
|
||
end
|
||
|
||
function PvpProxy:GetSpareTime()
|
||
return self.sparetime or 0;
|
||
end
|
||
|
||
function PvpProxy:ClearTeamPwsInfos()
|
||
helplog("ClearTeamPwsInfos");
|
||
|
||
self.sparetime = nil;
|
||
self.server_teamPwsInfo = nil;
|
||
end
|
||
-- 組隊競技戰 副本資訊 end
|