368 lines
9.1 KiB
Plaintext
368 lines
9.1 KiB
Plaintext
autoImport("BoothData")
|
|
autoImport("ShopMallItemData")
|
|
autoImport("ExchangeLogData")
|
|
|
|
BoothProxy = class('BoothProxy', pm.Proxy)
|
|
BoothProxy.Instance = nil;
|
|
BoothProxy.NAME = "BoothProxy"
|
|
|
|
BoothProxy.OperEnum = {
|
|
Open = SceneUser2_pb.EBOOTHOPER_OPEN,
|
|
Close = SceneUser2_pb.EBOOTHOPER_CLOSE,
|
|
Update = SceneUser2_pb.EBOOTHOPER_UPDATE,
|
|
}
|
|
|
|
BoothProxy.TradeType = {
|
|
All = SceneItem_pb.ETRADETYPE_ALL,
|
|
Exchange = SceneItem_pb.ETRADETYPE_TRADE,
|
|
Booth = SceneItem_pb.ETRADETYPE_BOOTH,
|
|
}
|
|
|
|
local _ArrayPushBack = TableUtility.ArrayPushBack
|
|
local _ArrayClear = TableUtility.ArrayClear
|
|
|
|
function BoothProxy:ctor(proxyName, data)
|
|
self.proxyName = proxyName or BoothProxy.NAME
|
|
if(BoothProxy.Instance == nil) then
|
|
BoothProxy.Instance = self
|
|
end
|
|
if data ~= nil then
|
|
self:setData(data)
|
|
end
|
|
|
|
self:Init()
|
|
end
|
|
|
|
function BoothProxy:Init()
|
|
self.bagSell = {}
|
|
self.itemPool = LuaLRUKeyTable.new(5, 50)
|
|
self.boothSellRecordList = {}
|
|
self.boothRecieveRecord = {}
|
|
self.tableTakeLog = {}
|
|
end
|
|
|
|
function BoothProxy:RecvBoothReqUserCmd(serverData)
|
|
if serverData.success == true then
|
|
local oper = serverData.oper
|
|
local myself = Game.Myself
|
|
if oper == self.OperEnum.Open then
|
|
FunctionSystem.InterruptMyselfAI()
|
|
myself:Client_NoMove(true)
|
|
|
|
self:SetSimulateMode()
|
|
elseif oper == self.OperEnum.Close then
|
|
myself:Client_NoMove(false)
|
|
myself:DestroyBooth()
|
|
end
|
|
end
|
|
end
|
|
|
|
function BoothProxy:RecvBoothInfoSyncUserCmd(serverData)
|
|
local oper = serverData.oper
|
|
local player = NSceneUserProxy.Instance:Find(serverData.charid)
|
|
if player ~= nil then
|
|
if oper == self.OperEnum.Open or oper == self.OperEnum.Update then
|
|
player:UpdateBooth(serverData.info)
|
|
if oper == self.OperEnum.Open then
|
|
EventManager.Me():DispatchEvent(BoothEvent.OpenBooth, player)
|
|
end
|
|
elseif oper == self.OperEnum.Close then
|
|
player:DestroyBooth()
|
|
EventManager.Me():DispatchEvent(BoothEvent.CloseBooth, player)
|
|
end
|
|
end
|
|
end
|
|
|
|
function BoothProxy:RecvBoothPlayerPendingListCmd(serverData)
|
|
local charid = serverData.charid
|
|
local element = self.itemPool:TryGetValueNoRemove(charid)
|
|
if element == nil then
|
|
element = {}
|
|
self.itemPool:Add(charid, element)
|
|
else
|
|
_ArrayClear(element)
|
|
end
|
|
|
|
for i=1,#serverData.lists do
|
|
local itemData = ShopMallItemData.new(serverData.lists[i])
|
|
_ArrayPushBack(element, itemData)
|
|
end
|
|
end
|
|
|
|
function BoothProxy:RecvUpdateOrderTradeCmd(serverData)
|
|
local charid = serverData.charid
|
|
local element = self.itemPool:TryGetValueNoRemove(charid)
|
|
if element ~= nil then
|
|
local info = serverData.info
|
|
local orderId = info.order_id
|
|
local item
|
|
for i=1,#element do
|
|
item = element[i]
|
|
if item.orderId == orderId then
|
|
item:SetData(info)
|
|
break
|
|
end
|
|
end
|
|
|
|
if item == nil then
|
|
local itemData = ShopMallItemData.new(info)
|
|
_ArrayPushBack(element, itemData)
|
|
end
|
|
end
|
|
end
|
|
|
|
function BoothProxy:ClearMyselfBooth()
|
|
local _ServiceNUserProxy = ServiceNUserProxy.Instance
|
|
local _OperClose = self.OperEnum.Close
|
|
local data = ReusableTable.CreateTable()
|
|
data.oper = _OperClose
|
|
data.success = true
|
|
_ServiceNUserProxy:RecvBoothReqUserCmd(data)
|
|
ReusableTable.DestroyTable(data)
|
|
end
|
|
|
|
function BoothProxy:GetScoreLevel(score)
|
|
local _ScoreConfig = GameConfig.Booth.score
|
|
local index = 0
|
|
for i=0,#_ScoreConfig do
|
|
if score >= _ScoreConfig[i].num then
|
|
index = i
|
|
else
|
|
break
|
|
end
|
|
end
|
|
|
|
return index
|
|
end
|
|
|
|
function BoothProxy:GetQuota(price, publicityId)
|
|
if publicityId == nil then
|
|
return 0
|
|
end
|
|
|
|
local _BoothConfig = GameConfig.Booth
|
|
local quota
|
|
if publicityId == 0 then
|
|
quota = price / _BoothConfig.quota_exchange_rate
|
|
else
|
|
quota = price / _BoothConfig.quota_exchange_rate_pub
|
|
end
|
|
if quota > _BoothConfig.quota_cost_max then
|
|
quota = _BoothConfig.quota_cost_max
|
|
end
|
|
return quota
|
|
end
|
|
|
|
--有效額度
|
|
function BoothProxy:GetValidQuota(quota)
|
|
local lockQuota = MyselfProxy.Instance:GetQuotaLock()
|
|
if quota > lockQuota then
|
|
return lockQuota, true
|
|
end
|
|
return quota, false
|
|
end
|
|
|
|
--折后價格
|
|
function BoothProxy:GetDiscountMoney(money)
|
|
return money * ( 1 - 1 / GameConfig.Booth.quota_zeny_discount)
|
|
end
|
|
|
|
function BoothProxy:GetExchangeBagSell()
|
|
TableUtility.ArrayClear(self.bagSell)
|
|
|
|
self:GetExchangeBagSellByBagType(BagProxy.BagType.MainBag)
|
|
self:GetExchangeBagSellByBagType(BagProxy.BagType.Barrow)
|
|
self:GetExchangeBagSellByBagType(BagProxy.BagType.PersonalStorage)
|
|
|
|
return self.bagSell
|
|
end
|
|
|
|
function BoothProxy:GetExchangeBagSellByBagType(bagType)
|
|
bagType = bagType or BagProxy.BagType.MainBag
|
|
local bagData = BagProxy.Instance.bagMap[bagType]
|
|
if bagData then
|
|
local items = bagData:GetItems()
|
|
for i=1,#items do
|
|
local itemData = items[i]
|
|
if self:CanItemBooth(itemData) then
|
|
table.insert(self.bagSell, itemData)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function BoothProxy:CanItemBooth(itemdata)
|
|
if itemdata == nil then
|
|
return false
|
|
end
|
|
|
|
if itemdata.enchantInfo and itemdata.enchantInfo:HasAttri() then
|
|
return false
|
|
end
|
|
|
|
return itemdata:CanTrade()
|
|
end
|
|
|
|
function BoothProxy:CanMapBooth()
|
|
local map = Game.MapManager:GetMapID()
|
|
local allowMaps = GameConfig.Booth.map_ids
|
|
for k,v in pairs(allowMaps) do
|
|
if map == v then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BoothProxy:GetItemList(charid)
|
|
return self.itemPool:TryGetValueNoRemove(charid) or {}
|
|
end
|
|
|
|
-- 將售罄物品移除
|
|
function BoothProxy:FilterItemList(charid)
|
|
local list = self:GetItemList(charid)
|
|
for i=#list, 1, -1 do
|
|
if list[i].count == 0 then
|
|
table.remove(list, i)
|
|
end
|
|
end
|
|
end
|
|
|
|
function BoothProxy:IsMaintenance()
|
|
return GameConfig.Booth.booth_maintenance == 1
|
|
end
|
|
|
|
function BoothProxy:SetSimulateMode(isSimulate, name)
|
|
self.isSimulate = isSimulate
|
|
self.simulateName = name
|
|
end
|
|
|
|
function BoothProxy:IsSimulateMode()
|
|
return self.isSimulate
|
|
end
|
|
|
|
function BoothProxy:GetName(playerID)
|
|
if playerID == nil then
|
|
return nil
|
|
end
|
|
|
|
if self.isSimulate and playerID == Game.Myself.data.id then
|
|
return self.simulateName
|
|
else
|
|
local player = NSceneUserProxy.Instance:Find(playerID)
|
|
if player ~= nil then
|
|
local boothData = player.data.boothData
|
|
if boothData ~= nil then
|
|
return boothData:GetName()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function BoothProxy:RecvExchangeRecord(data)
|
|
TableUtility.ArrayClear(self.boothSellRecordList)
|
|
|
|
for i=1,#data.log_list do
|
|
local logData = data.log_list[i]
|
|
if logData.itemid ~= 0 then--and not self:IsExpirePublicityBuyingLog(logData) then
|
|
local itemData = ExchangeLogData.new(logData)
|
|
if (BoothProxy.IsSell(itemData.type)) then
|
|
table.insert( self.boothSellRecordList , itemData )
|
|
|
|
if itemData.type ~= ShopMallLogTypeEnum.PublicityBuying and itemData.status == ShopMallLogReceiveEnum.ReceiveGive then
|
|
if not self:IsExistLog(self.boothRecieveRecord , itemData.id , itemData.type) then
|
|
TableUtility.ArrayPushBack(self.boothRecieveRecord , itemData)
|
|
|
|
--self:AddExchangeRecordRedTip()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort(self.boothSellRecordList ,function(l,r)
|
|
return l.tradetime > r.tradetime
|
|
end)
|
|
end
|
|
|
|
function BoothProxy:RecvTakeLog(data)
|
|
if data.success then
|
|
if data.log then
|
|
local id = data.log.id
|
|
local type = data.log.logtype
|
|
if id and type then
|
|
for i=1,#self.boothSellRecordList do
|
|
if self.boothSellRecordList[i].id == id and self.boothSellRecordList[i].type == type then
|
|
self.boothSellRecordList[i]:SetStatus( ShopMallLogReceiveEnum.Receive )
|
|
|
|
for j = #self.boothRecieveRecord,1,-1 do
|
|
local receiveData = self.boothRecieveRecord[j]
|
|
if receiveData.id == id and receiveData.type == type then
|
|
table.remove(self.boothRecieveRecord, j)
|
|
|
|
--self:RemoveExchangeRecordRedTip()
|
|
break
|
|
end
|
|
end
|
|
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function BoothProxy:RecvAddNewLog(serverData)
|
|
if serverData.log and serverData.log.id then
|
|
local itemData = ExchangeLogData.new(serverData.log)
|
|
if (itemData:CanReceive() and itemData.type == ShopMallLogTypeEnum.NormalBuy) then
|
|
TableUtility.TableClear(self.tableTakeLog)
|
|
self.tableTakeLog.id = itemData.id
|
|
self.tableTakeLog.logtype = itemData.type
|
|
self.tableTakeLog.trade_type = itemData.tradeType or BoothProxy.TradeType.Booth
|
|
ServiceRecordTradeProxy.Instance:CallTakeLogCmd(self.tableTakeLog)
|
|
end
|
|
if (BoothProxy.IsSell(itemData.type) and not self:IsExistLog(self.boothSellRecordList, data.log.id, data.log.type)) then
|
|
TableUtility.ArrayPushFront(self.boothSellRecordList , itemData)
|
|
end
|
|
end
|
|
|
|
local count = #self.boothSellRecordList
|
|
if count > GameConfig.Exchange.PageNumber then
|
|
table.remove(self.boothSellRecordList, count)
|
|
end
|
|
end
|
|
|
|
function BoothProxy:RecvCanTakeCount(data)
|
|
if data and data.count then
|
|
self.boothRecieveRecordCount = data.count
|
|
|
|
--[[if data.count < 1 then
|
|
RedTipProxy.Instance:RemoveWholeTip(SceneTip_pb.EREDSYS_TRADE_RECORD)
|
|
end]]
|
|
end
|
|
end
|
|
|
|
function BoothProxy:GetBoothSellRecordReceiveCount()
|
|
return self.boothRecieveRecordCount or 0
|
|
end
|
|
|
|
function BoothProxy:GetBoothSellRecordList()
|
|
return self.boothSellRecordList
|
|
end
|
|
|
|
function BoothProxy.IsSell(itemType)
|
|
return itemType and (itemType == ShopMallLogTypeEnum.NormalSell or itemType == ShopMallLogTypeEnum.PublicitySellSuccess)
|
|
end
|
|
|
|
function BoothProxy:IsExistLog(list,logId,type)
|
|
for i=1,#list do
|
|
local data = list[i]
|
|
if data.id == logId and data.type == type then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|