3335 拍卖行修改

client_linchunjie

2019-03-30 1a9fb969a2d27cf9d133348164ea39c3cc60144a

3335 拍卖行修改

 System/Auction/AuctionInquiryModel.cs

@@ -47,23 +47,13 @@
    }
    public class AuctionInquiryModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk

    {

        public Dictionary<string, AuctionItem> PlayerAuctionItemInfoDic = new Dictionary<string, AuctionItem>();//自身玩家上架的拍品

        public event Action PlayerAuctionItem;



        public List<AuctionItem> FullServiceAuctionList = new List<AuctionItem>();//全服拍品列表

        public event Action FullServiceAuctionUpdate;//全服拍品数据请求



        public Dictionary<string, AuctionItem> PlayerAuctionItemInfoDic = new Dictionary<string, AuctionItem>();//自身玩家上架的拍品

        public Dictionary<string, AuctionItem> FamilyAuctionItemDic = new Dictionary<string, AuctionItem>();// 拍卖行仙盟拍卖中的物品信息



        public Dictionary<string, AuctionItem> PlayerAuctionRecordDic = new Dictionary<string, AuctionItem>();//拍卖行玩家拍卖记录



        public Dictionary<int, AddAuctionItemInfoClass> AddAuctionItemInfoDic = new Dictionary<int, AddAuctionItemInfoClass>();//关注的拍品的上架提醒（弹框显示）

        public event Action AddAuctionItemInfoUpdate;



        public Dictionary<string, AuctionItem> BiddingItemInfoDic = new Dictionary<string, AuctionItem>();//拍卖行玩家竞价中的物品信息 



        public Dictionary<string, AuctionItem> AttentionAuctionItemDic = new Dictionary<string, AuctionItem>();//拍卖行关注中的拍品详情



        public Dictionary<int, int> AttentionAuctionItemIDdic = new Dictionary<int, int>();//关注的物品ID



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

@@ -78,6 +68,10 @@
            get { return locationQuery; }

            set { locationQuery = value; }

        }



        public event Action PlayerAuctionItem;

        public event Action FullServiceAuctionUpdate;//全服拍品数据请求

        public event Action AddAuctionItemInfoUpdate;



        public override void Init()

        {

@@ -157,6 +151,11 @@
            return BiddingItemInfoDic.TryGetValue(guid, out item);

        }



        public bool TryGetFairyAuctionItem(string guid, out AuctionItem item)

        {

            return FamilyAuctionItemDic.TryGetValue(guid, out item);

        }



        public List<string> GetServerAuctionItems()

        {

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

@@ -172,6 +171,11 @@
            return BiddingItemInfoDic.Keys;

        }



        public ICollection<string> GetFairyAuctionItems()

        {

            return FamilyAuctionItemDic.Keys;

        }



        public bool IsParticipateInBidding(string guid)

        {

            return BiddingItemInfoDic.ContainsKey(guid);


 System/Auction/AuctionLogicUtil.cs

@@ -149,7 +149,12 @@
            {

                return false;

            }



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

            if (itemConfig.EquipPlace == 0)

            {

                return false;

            }



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




 System/Auction/FamilyAuctionWin.cs

@@ -19,7 +19,8 @@
        AuctionModel auctionModel { get { return ModelCenter.Instance.GetModel<AuctionModel>(); } }

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

        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }
        List<AuctionItem> FamilyAuctionList = new List<AuctionItem>();

        List<string> fairyAuctionItems = new List<string>();
        #region Built-in
        protected override void BindController()
        {

@@ -34,16 +35,19 @@
        {

            GetFamilyAuctionItemList();

            ListSotr();



            OnCreateGridCellItem(m_ScrollerControllerItem);

            var index = FamilyAuctionList.FindIndex((x) =>

            var index = fairyAuctionItems.FindIndex((x) =>

             {

                 return x.itemGuid.Equals(auctionModel.locationItemGuid);

                 return x.Equals(auctionModel.locationItemGuid);

             });

            if (index != -1)

            {

                m_ScrollerControllerItem.JumpIndex(index);

            }

            auctionModel.locationItemGuid = string.Empty;
        }

@@ -70,136 +74,99 @@
        {
        }

        #endregion

        private void FamilyAuctionReset()

        {

            GetFamilyAuctionItemList();

            ListSotr();

            OnCreateGridCellItem(m_ScrollerControllerItem);

        }



        private void RefreshAuctionItemUpdate()

        {

            m_ScrollerControllerItem.m_Scorller.RefreshActiveCellViews();//刷新可见

        }



        private void OnCreateGridCellItem(ScrollerController gridCtrl)

        {

            gridCtrl.Refresh();



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

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

            {

                gridCtrl.AddCell(ScrollerDataType.Header, i);

            }

            gridCtrl.Restart();

        }

        private void OnRefreshGridCellItem(ScrollerDataType type, CellView cell)

        {

            int index = cell.index;

            var ItemGUID = FamilyAuctionList[index].itemGuid;

            FamilyAuctioncell familyAuctionCell = cell.GetComponent<FamilyAuctioncell>();

            familyAuctionCell.GetFamilyAuctionGUID(ItemGUID);

            familyAuctionCell.GetFamilyAuctionGUID(fairyAuctionItems[index]);

        }



        private void GetFamilyAuctionItemList()

        {

            FamilyAuctionList.Clear();

            foreach (var value in model.FamilyAuctionItemDic.Values)

            fairyAuctionItems.Clear();

            var itemGuids = model.GetFairyAuctionItems();

            foreach (var guid in itemGuids)

            {

                if (value.auctionType == 1)

                AuctionItem item;

                if(model.TryGetFairyAuctionItem(guid,out item))

                {

                    FamilyAuctionList.Add(value);

                    if (item.auctionType == 1)

                    {

                        fairyAuctionItems.Add(guid);

                    }

                }

               
            }

        }

        private void ListSotr()

        {

            FamilyAuctionList.Sort(Compare);

            fairyAuctionItems.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.TryGetFairyAuctionItem(x, out lhs)

                && model.TryGetFairyAuctionItem(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 = AuctionLogicUtil.IsMyTopPrice(lhs);

                var rhs_myTopPrice = AuctionLogicUtil.IsMyTopPrice(rhs);

                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;

        }

    }

}

 System/Auction/FamilyAuctioncell.cs

@@ -36,242 +36,137 @@
        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 FamilyAuctionItem;



        bool cacheIsWarmUp = false;

        string auctionItemGuid;



        bool m_IsWarmUp = false;

        bool isWarmUp

        {

            get { return m_IsWarmUp; }

            set

            {

                if (value != m_IsWarmUp)

                {

                    m_IsWarmUp = value;

                    AuctionItem auctionItem;

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

                    {

                        Display(auctionItem);

                    }

                }

            }

        }



        float timer = 0f;


        public void GetFamilyAuctionGUID(string GUIID)

        public void GetFamilyAuctionGUID(string guid)

        {

            m_NeedImage.SetActive(false);

            m_ParticipateImage.SetActive(false);

            m_HighestPriceImage.SetActive(false);

            m_EquipmentScoreObj.SetActive(false);

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



            AuctionItem auctionItem;

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

            {

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

                return;

            }

            var familyAuctionItem = model.FamilyAuctionItemDic[GUIID];

            FamilyAuctionItem = familyAuctionItem;

            var playerId = PlayerDatas.Instance.baseData.PlayerID;

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

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

            if (itemConfig == null)

            {

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

                return;

            }

            if (auctionItem == null)

            {

                DebugEx.LogError("拍卖物品表没有找到该物品，物品ID为" + familyAuctionItem.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);

                }

            }



            DisplayState();

            this.auctionItemGuid = guid;



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

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



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

            {

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

            }



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

            m_ItemCell.Init(cellModel);

            m_ItemCell.button.SetListener(() =>

            {

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

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

                itemTipsModel.SetItemTipsModel(attrData);

            });



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

            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 * familyAuctionItem.itemCount;

            if (familyAuctionItem.biddingPrice == 0)



            int requireMoney = AuctionLogicUtil.GetBiddingRequireMoney(auctionItem);



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

            var topPrice = config.BuyoutPrice * auctionItem.itemCount;



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

            {

                needJade = auctionItem.BasePrice * familyAuctionItem.itemCount;

                requireMoney = topPrice;

            }

            else

            {

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

            }

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

            {

                needJade = priceMax;

            }

            m_JadeNumber.text = familyAuctionItem.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 && FamilyAuctionItem != null)

            timer += Time.deltaTime;

            if (timer >= 0.5f)

            {

                var timeNow = TimeUtility.ServerNow;

                TimeSpan timeSpan = timeNow - FamilyAuctionItem.putAwayTime;

                int minute = (int)timeSpan.TotalMinutes;



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

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

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

                timer = 0f;

                AuctionItem auctionItem;

                if (model.TryGetFairyAuctionItem(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 (FamilyAuctionItem.biddingTime >= overTime)

                    {

                        realOverTime = FamilyAuctionItem.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(FamilyAuctionItem) != cacheIsWarmUp)

                {

                    DisplayState();

                    DisplayTime(auctionItem);

                    isWarmUp = AuctionLogicUtil.IsAuctionItemWarmUp(auctionItem);

                }

            }

        }

        void DisplayState()

        void Display(AuctionItem auctionItem)

        {

            if (FamilyAuctionItem != null)

            {

                cacheIsWarmUp = auctionHelpModel.IsItemWarmUp(FamilyAuctionItem);

                if (cacheIsWarmUp)

                {

                    m_BiddingText.text = Language.Get("PMH_17");

                }

                else if (FamilyAuctionItem.biddingPrice != 0)

                {

                    m_BiddingText.text = Language.Get("PMH_06");

                }

                else

                {

                    m_BiddingText.text = Language.Get("PMH_05");

                }

            }

        }

        private void SetButtonStatus()

            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);

        }



        void DisplayTime(AuctionItem auctionItem)

        {

            var maxMoney = AuctionItem.BuyoutPrice * FamilyAuctionItem.itemCount;

            var needMoney = 0;

            if (FamilyAuctionItem.biddingPrice == 0)

            {

                needMoney = AuctionItem.BasePrice * FamilyAuctionItem.itemCount;

            }

            else

            {

                needMoney = FamilyAuctionItem.biddingPrice + AuctionItem.BiddingAdd * FamilyAuctionItem.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;

            }

            m_TimeText.text = AuctionLogicUtil.GetBiddingTimeLabel(auctionItem);

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

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

        }
    }


 System/Auction/FullServiceAuctioncell.cs

@@ -95,8 +95,6 @@
            }

            #endregion



            var playerId = PlayerDatas.Instance.baseData.PlayerID;



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



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