3335 拍卖行修改

client_linchunjie

2019-03-30 8f8be54ff7c9d7dacf2b392584a5dd99bf8802d8

3335 拍卖行修改

 System/Auction/AuctionInquiryModel.cs

@@ -165,6 +165,15 @@
            return FamilyAuctionItemDic.TryGetValue(guid, out item);

        }



        public bool TryGetMyFocusAuctionItem(string guid, out AuctionItem item)

        {

            if (AttentionAuctionItemDic.TryGetValue(guid, out item))

            {

                return true;

            }

            return FamilyAuctionItemDic.TryGetValue(guid, out item);

        }



        public List<string> GetServerAuctionItems()

        {

            List<string> guids = new List<string>();

@@ -204,6 +213,25 @@
            }

        }



        public void GetMyFocusAutionItems(ref List<string> itemGuids)

        {

            itemGuids.Clear();

            itemGuids.AddRange(AttentionAuctionItemDic.Keys);



            var playerId = PlayerDatas.Instance.baseData.PlayerID;

            foreach (var item in FamilyAuctionItemDic.Values)

            {

                if (itemGuids.Contains(item.itemGuid))

                {

                    continue;

                }

                if (AttentionAuctionItemIDdic.ContainsKey(item.itemId))

                {

                    itemGuids.Add(item.itemGuid);

                }

            }

        }



        public bool IsParticipateInBidding(string guid)

        {

            return BiddingItemInfoDic.ContainsKey(guid);


 System/Auction/FamilyAuctioncell.cs

@@ -81,6 +81,11 @@
                m_HighestPriceImage.gameObject.SetActive(true);

            }



            if (model.IsParticipateInBidding(guid))

            {

                m_ParticipateImage.SetActive(true);

            }



            ItemCellModel cellModel = new ItemCellModel(auctionItem.itemId, true, (ulong)auctionItem.itemCount);

            m_ItemCell.Init(cellModel);

            m_ItemCell.button.SetListener(() =>


 System/Auction/FullServiceAuctionWin.cs

@@ -382,17 +382,11 @@


        int MyBiddingItemCompare(string x, string y)//数组排列

        {

            AuctionItem lhs;

            AuctionItem rhs;

            if (model.TryGetMyBiddingAuctionItem(x, out lhs)

                && model.TryGetMyBiddingAuctionItem(y, out rhs))

            var lhs_myTopPrice = model.IsMyTopPrice(x);

            var rhs_myTopPrice = model.IsMyTopPrice(y);

            if (lhs_myTopPrice != rhs_myTopPrice)

            {

                var lhs_myTopPrice = AuctionLogicUtil.IsMyTopPrice(lhs);

                var rhs_myTopPrice = AuctionLogicUtil.IsMyTopPrice(rhs);

                if (lhs_myTopPrice != rhs_myTopPrice)

                {

                    return -lhs_myTopPrice.CompareTo(rhs_myTopPrice);

                }

                return -lhs_myTopPrice.CompareTo(rhs_myTopPrice);

            }

            return 1;

        }


 System/Auction/FullServiceAuctioncell.cs

@@ -97,9 +97,14 @@


            m_NeedImage.gameObject.SetActive(AuctionLogicUtil.IsSatisfyEquipBetterEquip(auctionItem));



            if (model.IsParticipateInBidding(guid))//参与了竞价的物品

            if (model.IsMyTopPrice(guid))//参与了竞价的物品

            {

                m_HighestPriceImage.gameObject.SetActive(AuctionLogicUtil.IsMyTopPrice(auctionItem));

                m_HighestPriceImage.gameObject.SetActive(true);

            }



            if (model.IsParticipateInBidding(guid))

            {

                m_ParticipateImage.SetActive(true);

            }



            ItemCellModel cellModel = new ItemCellModel(auctionItem.itemId, true, (ulong)auctionItem.itemCount);

@@ -182,7 +187,7 @@
            m_BiddingButton.SetInteractable(m_JadeNumber2, !isWarmUp && !isTopPrice);



            m_BiddingText.text = AuctionLogicUtil.GetBiddingStateLabel(auctionItem);

            if (AuctionLogicUtil.IsMyTopPrice(auctionItem))

            if (model.IsMyTopPrice(auctionItemGuid))

            {

                m_BiddingText.text = string.Empty;

            }


 System/Auction/MyFocusCell.cs

@@ -35,248 +35,146 @@
        AuctionInquiryModel model { get { return ModelCenter.Instance.GetModel<AuctionInquiryModel>(); } }

        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }

        ItemTipsModel itemTipsModel { get { return ModelCenter.Instance.GetModel<ItemTipsModel>(); } }

        private AuctionItemConfig AuctionItem;

        private AuctionItem MyFocusItem;



        bool cacheIsWarmUp = false;

        string auctionItemGuid;



        public void GetMyFocusGUID(string GUIID)

        bool m_IsWarmUp = false;

        bool isWarmUp

        {

            if (!model.AttentionAuctionItemDic.ContainsKey(GUIID) && !model.FamilyAuctionItemDic.ContainsKey(GUIID))

            get { return m_IsWarmUp; }

            set

            {

                //  DebugEx.LogError("未找到相应的拍品数据");

                if (value != m_IsWarmUp)

                {

                    m_IsWarmUp = value;

                    AuctionItem auctionItem;

                    if (model.TryGetMyFocusAuctionItem(auctionItemGuid, out auctionItem))

                    {

                        Display(auctionItem);

                    }

                }

            }

        }



        float timer = 0f;



        public void GetMyFocusGUID(string guid)

        {

            AuctionItem auctionItem;

            if (!model.TryGetMyFocusAuctionItem(guid, out auctionItem))

            {

                return;

            }

            this.auctionItemGuid = guid;



            m_NeedImage.SetActive(false);

            m_ParticipateImage.SetActive(false);

            m_HighestPriceImage.SetActive(false);

            m_EquipmentScoreObj.SetActive(false);

            AuctionItem myAuction = new AuctionItem();

            int type = 0;

            if (model.AttentionAuctionItemDic.ContainsKey(GUIID))

            {

                type = 0;

                myAuction = model.AttentionAuctionItemDic[GUIID];

            }

            if (model.FamilyAuctionItemDic.ContainsKey(GUIID))

            {

                type = 1;

                myAuction = model.FamilyAuctionItemDic[GUIID];

            }

            MyFocusItem = myAuction;



            var playerId = PlayerDatas.Instance.baseData.PlayerID;

            var auctionItem = AuctionItemConfig.Get(myAuction.itemId);

            var itemConfig = ItemConfig.Get(myAuction.itemId);

            if (itemConfig == null)

            var config = AuctionItemConfig.Get(auctionItem.itemId);

            var itemConfig = ItemConfig.Get(auctionItem.itemId);



            m_NeedImage.gameObject.SetActive(AuctionLogicUtil.IsSatisfyEquipBetterEquip(auctionItem));



            if (model.IsMyTopPrice(guid))//参与了竞价的物品

            {

                DebugEx.LogError("物品表没有找到该物品，物品ID为" + myAuction.itemId);

                return;

                m_HighestPriceImage.gameObject.SetActive(true);

            }

            if (auctionItem == null)



            if (model.IsParticipateInBidding(guid))

            {

                DebugEx.LogError("拍卖物品表没有找到该物品，物品ID为" + myAuction.itemId);

                return;

            }

            AuctionItem = auctionItem;

            var jobBool = itemConfig.JobLimit == PlayerDatas.Instance.baseData.Job;

            var equipNeedBool = auctionHelpModel.WhetherEquipped(itemConfig.LV, itemConfig.EquipPlace);

            if (!equipNeedBool && jobBool)//是否需要

            {

                m_NeedImage.SetActive(true);

            }

            if (model.BiddingItemInfoDic.ContainsKey(GUIID))//参与了竞价的物品

            {

                var biddingItemInfo = model.BiddingItemInfoDic[GUIID];

                m_ParticipateImage.SetActive(true);

                if (biddingItemInfo.biddingPlayer == playerId)//判断是否最高竞价

                {

                    m_HighestPriceImage.SetActive(true);

                }

                else

                {

                    m_HighestPriceImage.SetActive(false);



                }

            }



            DisplayState();



            ItemCellModel cellModel = new ItemCellModel(myAuction.itemId, true, (ulong)myAuction.itemCount);

            ItemCellModel cellModel = new ItemCellModel(auctionItem.itemId, true, (ulong)auctionItem.itemCount);

            m_ItemCell.Init(cellModel);

            m_ItemCell.button.SetListener(() =>

            {

                ItemAttrData attrData = new ItemAttrData(myAuction.itemId, true, (ulong)1);

                ItemAttrData attrData = new ItemAttrData(auctionItem.itemId, true, (ulong)1);

                itemTipsModel.SetItemTipsModel(attrData);

            });



            m_ItemName.text = itemConfig.ItemName;

            if (itemConfig.EquipPlace != 0)

            {

                m_EquipmentScoreObj.SetActive(true);

                m_Score.text = cellModel.score.ToString();

                var isMyJobItem = itemConfig.JobLimit == 0 || itemConfig.JobLimit == PlayerDatas.Instance.baseData.Job;

                var equipScore = auctionHelpModel.GetEquipScore(itemConfig.LV, itemConfig.EquipPlace);

                m_StateIcon.SetActive(cellModel.score > equipScore && jobBool);

                m_DeclineIcon.SetActive(equipScore > cellModel.score && jobBool);

                m_StateIcon.SetActive(cellModel.score > equipScore && isMyJobItem);

                m_DeclineIcon.SetActive(equipScore > cellModel.score && isMyJobItem);

            }

            else

            {

                m_EquipmentScoreObj.SetActive(false);

            }

            int needJade = 0;

            int priceMax = 0;

            priceMax = auctionItem.BuyoutPrice * myAuction.itemCount;



            priceMax = auctionItem.BuyoutPrice * myAuction.itemCount;

            if (myAuction.biddingPrice == 0)

            int requireMoney = AuctionLogicUtil.GetBiddingRequireMoney(auctionItem);



            var topPrice = config.BuyoutPrice * auctionItem.itemCount;



            if (config.BuyoutPrice != 0 && requireMoney > topPrice)//竞价价格永远不能大于最高价

            {

                needJade = auctionItem.BasePrice * myAuction.itemCount;

                requireMoney = topPrice;

            }

            else

            {

                needJade = myAuction.biddingPrice + auctionItem.BiddingAdd * myAuction.itemCount;

            }

            if (auctionItem.BuyoutPrice != 0 && needJade > priceMax)//竞价价格永远不能大于最高价

            {

                needJade = priceMax;

            }

            m_JadeNumber.text = myAuction.biddingPrice.ToString();

            m_JadeNumber1.text = priceMax.ToString();

            if (auctionItem.BuyoutPrice == 0)

            {

                m_PriceButton.gameObject.SetActive(false);

            }

            else

            {

                m_PriceButton.gameObject.SetActive(true);

            }



            m_JadeNumber.text = auctionItem.biddingPrice.ToString();

            m_JadeNumber1.text = topPrice.ToString();

            m_PriceButton.gameObject.SetActive(config.BuyoutPrice != 0);



            m_PriceButton.SetListener(() => //一口价

            {

                int jade = (int)PlayerDatas.Instance.baseData.diamond;

                string str = Language.Get("PMH_02", priceMax);

                ConfirmCancel.ShowPopConfirm(Language.Get("L1003"), str, (bool isOk) =>

                {

                    if (isOk)

                    {

                        if (jade >= priceMax)

                        {

                            AuctionInquiry.Instance.SendSellAuctionItem(GUIID, priceMax);

                        }

                        else

                        {

                            WindowCenter.Instance.Open<RechargeTipWin>();

                        }

                    }

                });

                AuctionLogicUtil.SendBiddingItem(auctionItem, true);

            });

            m_JadeNumber2.text = (needJade).ToString();



            m_JadeNumber2.text = requireMoney.ToString();



            m_BiddingButton.SetListener(() => //竞价

            {

                int jade = (int)PlayerDatas.Instance.baseData.diamond;

                string str = Language.Get("PMH_01", needJade);

                ConfirmCancel.ShowPopConfirm(Language.Get("L1003"), str, (bool isOk) =>

                {

                    if (isOk)

                    {

                        if (jade >= needJade)

                        {

                            AuctionInquiry.Instance.SendSellAuctionItem(GUIID, needJade);

                        }

                        else

                        {

                            WindowCenter.Instance.Open<RechargeTipWin>();

                        }

                    }

                });



                AuctionLogicUtil.SendBiddingItem(auctionItem, false);

            });



            Display(auctionItem);

            DisplayTime(auctionItem);

        }



        private void LateUpdate()

        {

            if (AuctionItem != null && MyFocusItem != null)

            timer += Time.deltaTime;

            if (timer >= 0.5f)

            {

                var timeNow = TimeUtility.ServerNow;

                TimeSpan timeSpan = timeNow - MyFocusItem.putAwayTime;

                int minute = (int)timeSpan.TotalMinutes;



                DateTime overTime = MyFocusItem.putAwayTime.AddMinutes(AuctionItem.FamilySaleMinutes + AuctionItem.NoticeSaleMinutes);

                DateTime extensionTime = MyFocusItem.biddingTime.AddSeconds(auctionHelpModel.ExtensionTime);

                if (minute < AuctionItem.NoticeSaleMinutes)//预热中

                timer = 0f;

                AuctionItem auctionItem;

                if (model.TryGetMyFocusAuctionItem(auctionItemGuid, out auctionItem))

                {

                    if (m_PriceButton.interactable)

                    {

                        m_PriceButton.interactable = false;

                        m_PriceImage.gray = true;

                    }

                    if (m_BiddingButton.interactable)

                    {

                        m_BiddingButton.interactable = false;

                        m_BiddingImage.gray = true;

                    }

                    int seconds = AuctionItem.NoticeSaleMinutes * 60 - (int)timeSpan.TotalSeconds;

                    m_TimeText.text = Language.Get("PMH_03", TimeUtility.SecondsToHMS(seconds));

                }

                else if (minute < (AuctionItem.FamilySaleMinutes + AuctionItem.NoticeSaleMinutes))//拍卖中

                {

                    SetButtonStatus();

                    int seconds = AuctionItem.FamilySaleMinutes * 60 - ((int)timeSpan.TotalSeconds - AuctionItem.NoticeSaleMinutes * 60);

                    m_TimeText.text = Language.Get("PMH_04", TimeUtility.SecondsToHMS(seconds));

                }

                if (overTime < extensionTime)//加时中

                {

                    SetButtonStatus();



                    var totalTick = auctionHelpModel.ExtensionTime * TimeSpan.TicksPerSecond;

                    var realOverTime = overTime.AddTicks(totalTick);

                    if (MyFocusItem.biddingTime >= overTime)

                    {

                        realOverTime = MyFocusItem.biddingTime.AddTicks(totalTick);

                    }

                    TimeSpan timeSpan2 = realOverTime - timeNow;

                    int timeSeconds = (int)timeSpan2.TotalSeconds;

                    m_TimeText.text = Language.Get("PMH_18", TimeUtility.SecondsToHMS(timeSeconds));

                    m_TimeText.color = UIHelper.GetUIColor(TextColType.Red, true);

                }



                if (auctionHelpModel.IsItemWarmUp(MyFocusItem) != cacheIsWarmUp)

                {

                    DisplayState();

                    DisplayTime(auctionItem);

                    isWarmUp = AuctionLogicUtil.IsAuctionItemWarmUp(auctionItem);

                }

            }

        }

        void DisplayState()

        }



        void Display(AuctionItem auctionItem)

        {

            m_BiddingText.text = AuctionLogicUtil.GetBiddingStateLabel(MyFocusItem);

        }

        private void SetButtonStatus()

        {

            var maxMoney = AuctionItem.BuyoutPrice * MyFocusItem.itemCount;

            var needMoney = 0;

            if (MyFocusItem.biddingPrice == 0)

            {

                needMoney = AuctionItem.BasePrice * MyFocusItem.itemCount;

            }

            else

            {

                needMoney = MyFocusItem.biddingPrice + AuctionItem.BiddingAdd * MyFocusItem.itemCount;

            }

            if (!m_PriceButton.interactable || m_PriceImage.gray)

            {

                m_PriceButton.interactable = true;

                m_PriceImage.gray = false;

            }

            if ((!m_BiddingButton.interactable || m_BiddingImage.gray) && maxMoney > needMoney)

            {

                m_BiddingButton.interactable = true;

                m_BiddingImage.gray = false;

            }

            if (m_BiddingButton.interactable && needMoney >= maxMoney && AuctionItem.BuyoutPrice != 0)

            {

                m_BiddingButton.interactable = false;

                m_BiddingImage.gray = true;

            }

            var isWarmUp = AuctionLogicUtil.IsAuctionItemWarmUp(auctionItem);

            m_PriceButton.SetInteractable(m_JadeNumber1, !isWarmUp);



            var isTopPrice = AuctionLogicUtil.IsBiddingUpperLimit(auctionItem);

            m_BiddingButton.SetInteractable(m_JadeNumber2, !isWarmUp && !isTopPrice);



            m_BiddingText.text = AuctionLogicUtil.GetBiddingStateLabel(auctionItem);

            if (model.IsMyTopPrice(auctionItemGuid))

            {

                m_BiddingText.text = string.Empty;

            }

        }



        void DisplayTime(AuctionItem auctionItem)

        {

            m_TimeText.text = AuctionLogicUtil.GetBiddingTimeLabel(auctionItem);

            var colortype = AuctionLogicUtil.IsAuctionItemExtraTime(auctionItem) ? TextColType.Red : TextColType.Green;

            m_TimeText.color = UIHelper.GetUIColor(colortype, true);

        }

    }

 System/Auction/MyFocusWin.cs

@@ -17,7 +17,9 @@
        [SerializeField] ScrollerController m_ScrollerController;

        AuctionInquiryModel model { get { return ModelCenter.Instance.GetModel<AuctionInquiryModel>(); } }

        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }

        List<AuctionItem> MyFocusList = new List<AuctionItem>();


        List<string> myFocusAuctionItems = new List<string>();

        int MaxFocusCount = 0;
        #region Built-in
        protected override void BindController()
@@ -87,123 +89,69 @@
        private void OnCreateGridLineCell(ScrollerController gridCtrl)

        {

            gridCtrl.Refresh();

            for (int i = 0; i < MyFocusList.Count; i++)

            for (int i = 0; i < myFocusAuctionItems.Count; i++)

            {

                gridCtrl.AddCell(ScrollerDataType.Header, i);

            }

            gridCtrl.Restart();

        }



        private void OnRefreshGridCell(ScrollerDataType type, CellView cell)

        {

            int index = cell.index;

            var ItemGUID = MyFocusList[index].itemGuid;

            MyFocusCell myAuctionCell = cell.GetComponent<MyFocusCell>();

            myAuctionCell.GetMyFocusGUID(ItemGUID);

            myAuctionCell.GetMyFocusGUID(myFocusAuctionItems[index]);

        }



        private void GetMyFocusList()

        {

            MyFocusList.Clear();

            foreach (var value in model.AttentionAuctionItemDic.Values)

            {

                MyFocusList.Add(value);

            }

            int playerID = (int)PlayerDatas.Instance.baseData.PlayerID;

            foreach (var value in model.FamilyAuctionItemDic.Values)

            {

                if (model.AttentionAuctionItemIDdic.ContainsKey(value.itemId))

                {

                    MyFocusList.Add(value);

                }

            }

            model.GetMyFocusAutionItems(ref myFocusAuctionItems);

        }



        private void ListSotr()

        {

            MyFocusList.Sort(Compare);

            myFocusAuctionItems.Sort(Compare);

        }

        int Compare(AuctionItem x, AuctionItem y)//数组排列



        int Compare(string x, string y)//数组排列

        {

            bool havex = IsHighestPrice(x.itemGuid);

            bool havey = IsHighestPrice(y.itemGuid);

            if (havex.CompareTo(havey) != 0)//是否最高价

            AuctionItem lhs;

            AuctionItem rhs;



            if (model.TryGetMyFocusAuctionItem(x, out lhs)

                && model.TryGetMyFocusAuctionItem(y, out rhs))

            {

                return -havex.CompareTo(havey);

            }

            bool havex1 = IsParticipate(x.itemGuid);

            bool havey1 = IsParticipate(y.itemGuid);

            if (havex1.CompareTo(havey1) != 0)//是否参与

            {

                return -havex1.CompareTo(havey1);

            }

            bool havex2 = IsNeedEquip(x.itemId);

            bool havey2 = IsNeedEquip(y.itemId);

            if (havex2.CompareTo(havey2) != 0)//是否需要

            {

                return -havex2.CompareTo(havey2);

            }

            int havex3 = TimeSort(x);

            int havey3 = TimeSort(y);

            if (havex3.CompareTo(havey3) != 0)//时间排序

            {

                return -havex3.CompareTo(havey3);

            }

            var auctionConfigX = AuctionItemConfig.Get(x.itemId);

            var auctionConfigY = AuctionItemConfig.Get(y.itemId);

            if (auctionConfigX.Sortpriority.CompareTo(auctionConfigY.Sortpriority) != 0)//按照拍卖物品表排序

            {

                return auctionConfigX.Sortpriority.CompareTo(auctionConfigY.Sortpriority);

                var lhs_myTopPrice = model.IsMyTopPrice(x);

                var rhs_myTopPrice = model.IsMyTopPrice(y);

                if (lhs_myTopPrice != rhs_myTopPrice)

                {

                    return -lhs_myTopPrice.CompareTo(rhs_myTopPrice);

                }

                var lhs_participate = model.IsParticipateInBidding(x);

                var rhs_participate = model.IsParticipateInBidding(y);

                if (lhs_participate != rhs_participate)

                {

                    return -lhs_participate.CompareTo(rhs_participate);

                }

                var lhs_needEquip = AuctionLogicUtil.IsSatisfyEquipBetterEquip(lhs);

                var rhs_needEquip = AuctionLogicUtil.IsSatisfyEquipBetterEquip(rhs);

                if (lhs_needEquip != rhs_needEquip)

                {

                    return -lhs_needEquip.CompareTo(rhs_needEquip);

                }

                if (lhs.putAwayTime != rhs.putAwayTime)

                {

                    return lhs.putAwayTime.CompareTo(rhs.putAwayTime);

                }

                var lhs_Config = AuctionItemConfig.Get(lhs.itemId);

                var rhs_Config = AuctionItemConfig.Get(rhs.itemId);

                if (lhs_Config.Sortpriority != rhs_Config.Sortpriority)//按照拍卖物品表排序

                {

                    return lhs_Config.Sortpriority.CompareTo(rhs_Config.Sortpriority);

                }

            }

            return 1;

        }



        private bool IsHighestPrice(string GUID)

        {

            bool isBool = false;

            int playerId = (int)PlayerDatas.Instance.baseData.PlayerID;

            if (model.BiddingItemInfoDic.ContainsKey(GUID))

            {

                var biddingItemInfo = model.BiddingItemInfoDic[GUID];

                isBool = biddingItemInfo.biddingPlayer == playerId;

            }

            return isBool;

        }



        private bool IsParticipate(string GUID)

        {

            bool isBool = false;

            if (model.BiddingItemInfoDic.ContainsKey(GUID))

            {

                isBool = true;

            }

            return isBool;

        }
        private bool IsNeedEquip(int itemId)

        {

            bool isBool = false;

            var itemConfig = ItemConfig.Get(itemId);

            if (itemConfig == null)

            {

                return false;

            }

            if (!auctionHelpModel.WhetherEquipped(itemConfig.LV, itemConfig.EquipPlace))

            {

                isBool = true;

            }

            return isBool;

        }
        private int TimeSort(AuctionItem auctionItemClass)

        {

            int scends = 0;

            var auctionItem = AuctionItemConfig.Get(auctionItemClass.itemId);

            if (auctionItem == null)

            {

                return 0;

            }

            var timeNow = TimeUtility.ServerNow;

            TimeSpan timeSpan = timeNow - auctionItemClass.putAwayTime;

            scends = (int)timeSpan.TotalSeconds;

            return scends;

        }
    }

}