Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

client_Wu Xijin

2019-03-29 e550bf2d7e566c74b88e063c18e813f9b55e8379

Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

 Core/NetworkPackage/DTCFile/ServerPack/HB5_Bourse/DTCB501_tagGCAuctionItemInfo.cs

@@ -12,6 +12,6 @@
    public override void Done(GameNetPackBasic vNetPack)

    {


        base.Done(vNetPack);


        HB501_tagGCAuctionItemInfo vNetData = vNetPack as HB501_tagGCAuctionItemInfo;
        model.AuctionItemInfo(vNetData);

        HB501_tagGCAuctionItemInfo vNetData = vNetPack as HB501_tagGCAuctionItemInfo;
        model.ReceivePackage(vNetData);

    }


}



 Lua/Gen/SnxxzUIAuctionItemClassWrap.cs

File was deleted

 Lua/Gen/SnxxzUIAuctionItemClassWrap.cs.meta

File was deleted

 Lua/Gen/XLuaGenAutoRegister.cs

@@ -891,9 +891,6 @@
            translator.DelayWrapLoader(typeof(Snxxz.UI.AuctionConfigClass), SnxxzUIAuctionConfigClassWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AuctionItemClass), SnxxzUIAuctionItemClassWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BetterEquipGetModel), SnxxzUIBetterEquipGetModelWrap.__Register);
        
        

 System/Auction/AuctionHelpModel.cs

@@ -218,6 +218,17 @@
            isBool = !string.IsNullOrEmpty(equipGuid);

            return isBool;

        }



        public bool IsItemWarmUp(AuctionItem item)

        {

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

            if (config == null)

            {

                return false;

            }

            var ts = TimeUtility.ServerNow - item.putAwayTime;

            return ts.TotalMinutes < config.NoticeSaleMinutes;

        }

    }

}

 System/Auction/AuctionHouseWin.cs

@@ -58,7 +58,7 @@
        }

        protected override void OnActived()

        {

            OnClickFullServiceAuction();

            //OnClickFullServiceAuction();

            m_FuncBtnGroup.TriggerByOrder(functionOrder);

        }
        protected override void OnAfterOpen()

 System/Auction/AuctionInquiry.cs

@@ -26,6 +26,9 @@
    {

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

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

        public string locationGuid = string.Empty;

        public int GetSendNumber()//获取当前拍卖列表的索引类型

        {

            var sendNumber = 0;

@@ -86,6 +89,7 @@
        {

            if (model.FamilyAuctionItemDic.ContainsKey(itemGUID))

            {

                locationGuid = itemGUID;

                WindowCenter.Instance.Open<AuctionHouseWin>(true, 1);

            }

            else


 System/Auction/AuctionInquiryModel.cs

@@ -10,27 +10,28 @@

namespace Snxxz.UI

{
    [XLua.LuaCallCSharp]
    public class AuctionItemClass

    public class AuctionItem

    {

        public string ItemGUID;//物品GUID

        public int FamilyID;        //有值时为仙盟拍品

        public int ItemID;//物品ID

        public int ItemCount;

        public string TimeStr;//上架时间 yyyy-MM-dd hh:mm:ss

        public DateTime Time;//上架时间

        public DateTime TimeEnd;//最后上架时间

        public int BidderPrice;//竞拍玩家出价

        public string UserData;//自定义数据

        public string FamilyPlayerIDInfo;//可获得收益的仙盟玩家ID信息

        public List<int> FamilyPlayerIDList;//可获得收益的仙盟玩家ID信息存储

        public int AuctionType;//拍品类型，0-全服拍品，1-仙盟拍品

        public string itemGuid;

        public int itemId;                        //物品ID

        public int itemCount;



        public int RecordType;//记录类型 0-我的拍品记录 1-仙盟拍品记录 2-我的竞拍记录

        public int RecordResult;//记录结果 0-流拍 1-拍卖成交 2-回收 3-竞价成功 4-竞价失败

        public string BidderName;//成交玩家名

        public int auctionType;                   //拍品类型，0-全服拍品，1-仙盟拍品



        public int BidderID;//竞拍玩家ID，也就是当前最高竞价玩家ID

        public DateTime putAwayTime;              //上架时间

        public DateTime latestBiddingTime;        //最新竞价时间



        public string customData;                 //自定义数据



        public int familyId;                      //有值时为仙盟拍品

        public List<int> familyPlayers;           //可获得收益的仙盟玩家ID信息存储



        public int recordType;                    //记录类型 0-我的拍品记录 1-仙盟拍品记录 2-我的竞拍记录

        public int recordResult;                  //记录结果 0-流拍 1-拍卖成交 2-回收 3-竞价成功 4-竞价失败



        public int biddingPrice;                  //竞拍玩家出价

        public int biddingPlayer;                 //竞拍玩家ID，也就是当前最高竞价玩家ID

        public string biddingPlayerName;          //成交玩家名

    }

    public class AddAuctionItemInfoClass

@@ -46,22 +47,22 @@
    }
    public class AuctionInquiryModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk

    {

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

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

        public event Action PlayerAuctionItem;



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

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

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



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

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



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

        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, AuctionItemClass> BiddingItemInfoDic = new Dictionary<string, AuctionItemClass>();//拍卖行玩家竞价中的物品信息 
        public Dictionary<string, AuctionItem> BiddingItemInfoDic = new Dictionary<string, AuctionItem>();//拍卖行玩家竞价中的物品信息 


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

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



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



@@ -119,27 +120,29 @@
            }

        }



        public void AuctionItemInfo(HB501_tagGCAuctionItemInfo info)// 拍卖行拍卖中的物品信息

        public void ReceivePackage(HB501_tagGCAuctionItemInfo info)// 拍卖行拍卖中的物品信息

        {

            List<AuctionItemClass> fullServiceAuctionList = new List<AuctionItemClass>();

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

            for (int i = 0; i < info.AuctionItemCount; i++)

            {

                var PlayerAuctionItem = info.AuctionItemList[i];

                AuctionItemClass playerAuctionItemClass = new AuctionItemClass();

                playerAuctionItemClass.ItemGUID = PlayerAuctionItem.ItemGUID;

                playerAuctionItemClass.FamilyID = (int)PlayerAuctionItem.FamilyID;

                playerAuctionItemClass.ItemID = (int)PlayerAuctionItem.ItemID;

                playerAuctionItemClass.ItemCount = (int)PlayerAuctionItem.ItemCount;

                playerAuctionItemClass.TimeStr = PlayerAuctionItem.AddTime;

                playerAuctionItemClass.Time = DateTime.Parse(PlayerAuctionItem.AddTime);

                AuctionItem playerAuctionItemClass = new AuctionItem();

                playerAuctionItemClass.itemGuid = UIHelper.ServerStringTrim(PlayerAuctionItem.ItemGUID);

                playerAuctionItemClass.familyId = (int)PlayerAuctionItem.FamilyID;

                playerAuctionItemClass.itemId = (int)PlayerAuctionItem.ItemID;

                playerAuctionItemClass.itemCount = (int)PlayerAuctionItem.ItemCount;

                playerAuctionItemClass.putAwayTime = DateTime.Parse(PlayerAuctionItem.AddTime);

                var str = UIHelper.ServerStringTrim(PlayerAuctionItem.BiddingTime);

                if (!str.Equals(string.Empty))

                {

                    playerAuctionItemClass.TimeEnd = DateTime.Parse(str);

                    playerAuctionItemClass.latestBiddingTime = DateTime.Parse(str);

                }

                playerAuctionItemClass.BidderPrice = PlayerAuctionItem.BidderPrice;

                playerAuctionItemClass.UserData = PlayerAuctionItem.UserData;

                var index = FullServiceAuctionList.FindIndex((x) => { return x.ItemGUID == PlayerAuctionItem.ItemGUID; });

                playerAuctionItemClass.biddingPrice = PlayerAuctionItem.BidderPrice;

                playerAuctionItemClass.customData = PlayerAuctionItem.UserData;

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

                {

                    return x.itemGuid == playerAuctionItemClass.itemGuid;

                });

                if (index == -1)

                {

                    fullServiceAuctionList.Add(playerAuctionItemClass);

@@ -149,15 +152,7 @@
            if (info.QueryDir == 1)//往后查询

            {

                QueryRemaining.DownBool = info.QueryRemainlCount != 0;

                if (FullServiceAuctionList.Count == 0)

                {

                    FullServiceAuctionList.InsertRange(0, fullServiceAuctionList);

                }

                else

                {

                    FullServiceAuctionList.InsertRange(FullServiceAuctionList.Count - 1, fullServiceAuctionList);

                }



                FullServiceAuctionList.AddRange(fullServiceAuctionList);

            }

            else if (info.QueryDir == 2)//往前查询

            {

@@ -166,14 +161,7 @@
            }

            else if (info.QueryDir == 3)//定位查询

            {

                if (FullServiceAuctionList.Count == 0)

                {

                    FullServiceAuctionList.InsertRange(0, fullServiceAuctionList);

                }

                else

                {

                    FullServiceAuctionList.InsertRange(FullServiceAuctionList.Count - 1, fullServiceAuctionList);

                }

                FullServiceAuctionList.AddRange(fullServiceAuctionList);

                LocationQuery = true;

                WindowCenter.Instance.Open<AuctionHouseWin>(true, 0);//定位查询

            }

@@ -189,27 +177,26 @@
            for (int i = 0; i < info.AuctionItemCount; i++)

            {

                var PlayerAuctionItem = info.AuctionItemList[i];

                AuctionItemClass playerAuctionItemClass = new AuctionItemClass();

                playerAuctionItemClass.ItemGUID = PlayerAuctionItem.ItemGUID;

                playerAuctionItemClass.FamilyID = (int)PlayerAuctionItem.FamilyID;

                playerAuctionItemClass.ItemID = (int)PlayerAuctionItem.ItemID;

                playerAuctionItemClass.ItemCount = (int)PlayerAuctionItem.ItemCount;

                playerAuctionItemClass.TimeStr = PlayerAuctionItem.AddTime;

                playerAuctionItemClass.Time = DateTime.Parse(PlayerAuctionItem.AddTime);

                AuctionItem playerAuctionItemClass = new AuctionItem();

                playerAuctionItemClass.itemGuid = UIHelper.ServerStringTrim(PlayerAuctionItem.ItemGUID);

                playerAuctionItemClass.familyId = (int)PlayerAuctionItem.FamilyID;

                playerAuctionItemClass.itemId = (int)PlayerAuctionItem.ItemID;

                playerAuctionItemClass.itemCount = (int)PlayerAuctionItem.ItemCount;

                playerAuctionItemClass.putAwayTime = DateTime.Parse(PlayerAuctionItem.AddTime);

                var str = UIHelper.ServerStringTrim(PlayerAuctionItem.BiddingTime);

                if (!str.Equals(string.Empty))

                {

                    playerAuctionItemClass.TimeEnd = DateTime.Parse(str);

                    playerAuctionItemClass.latestBiddingTime = DateTime.Parse(str);

                }

                playerAuctionItemClass.BidderPrice = PlayerAuctionItem.BidderPrice;

                playerAuctionItemClass.UserData = PlayerAuctionItem.UserData;

                if (PlayerAuctionItemInfoDic.ContainsKey(playerAuctionItemClass.ItemGUID))

                playerAuctionItemClass.biddingPrice = PlayerAuctionItem.BidderPrice;

                playerAuctionItemClass.customData = PlayerAuctionItem.UserData;

                if (PlayerAuctionItemInfoDic.ContainsKey(playerAuctionItemClass.itemGuid))

                {

                    PlayerAuctionItemInfoDic[playerAuctionItemClass.ItemGUID] = playerAuctionItemClass;

                    PlayerAuctionItemInfoDic[playerAuctionItemClass.itemGuid] = playerAuctionItemClass;

                }

                else

                {

                    PlayerAuctionItemInfoDic.Add(playerAuctionItemClass.ItemGUID, playerAuctionItemClass);

                    PlayerAuctionItemInfoDic.Add(playerAuctionItemClass.itemGuid, playerAuctionItemClass);

                }

            }

            if (PlayerAuctionItem != null)

@@ -224,25 +211,24 @@
            for (int i = 0; i < info.Count; i++)

            {

                var PlayerAuctionRecord = info.AuctionRecordList[i];

                AuctionItemClass playerAuctionRecordClass = new AuctionItemClass();

                playerAuctionRecordClass.ItemGUID = PlayerAuctionRecord.ItemGUID;

                playerAuctionRecordClass.FamilyID = (int)PlayerAuctionRecord.FamilyID;

                playerAuctionRecordClass.TimeStr = PlayerAuctionRecord.RecordTime;//记录时间

                playerAuctionRecordClass.Time = DateTime.Parse(PlayerAuctionRecord.RecordTime);

                playerAuctionRecordClass.RecordType = PlayerAuctionRecord.RecordType;//记录类型 0-我的拍品记录 1-仙盟拍品记录 2-我的竞拍记录

                playerAuctionRecordClass.RecordResult = PlayerAuctionRecord.RecordResult;//记录结果 0-流拍 1-拍卖成交 2-回收 3-竞价成功 4-竞价失败

                playerAuctionRecordClass.BidderPrice = (int)PlayerAuctionRecord.BidderPrice;//成交价格

                playerAuctionRecordClass.BidderName = PlayerAuctionRecord.BidderName;//玩家名

                playerAuctionRecordClass.ItemID = (int)PlayerAuctionRecord.ItemID;

                playerAuctionRecordClass.ItemCount = (int)PlayerAuctionRecord.ItemCount;

                playerAuctionRecordClass.UserData = PlayerAuctionRecord.UserData;

                if (PlayerAuctionRecordDic.ContainsKey(playerAuctionRecordClass.ItemGUID))

                AuctionItem playerAuctionRecordClass = new AuctionItem();

                playerAuctionRecordClass.itemGuid = UIHelper.ServerStringTrim(PlayerAuctionRecord.ItemGUID);

                playerAuctionRecordClass.familyId = (int)PlayerAuctionRecord.FamilyID;

                playerAuctionRecordClass.putAwayTime = DateTime.Parse(PlayerAuctionRecord.RecordTime);

                playerAuctionRecordClass.recordType = PlayerAuctionRecord.RecordType;//记录类型 0-我的拍品记录 1-仙盟拍品记录 2-我的竞拍记录

                playerAuctionRecordClass.recordResult = PlayerAuctionRecord.RecordResult;//记录结果 0-流拍 1-拍卖成交 2-回收 3-竞价成功 4-竞价失败

                playerAuctionRecordClass.biddingPrice = (int)PlayerAuctionRecord.BidderPrice;//成交价格

                playerAuctionRecordClass.biddingPlayerName = PlayerAuctionRecord.BidderName;//玩家名

                playerAuctionRecordClass.itemId = (int)PlayerAuctionRecord.ItemID;

                playerAuctionRecordClass.itemCount = (int)PlayerAuctionRecord.ItemCount;

                playerAuctionRecordClass.customData = PlayerAuctionRecord.UserData;

                if (PlayerAuctionRecordDic.ContainsKey(playerAuctionRecordClass.itemGuid))

                {

                    PlayerAuctionRecordDic[playerAuctionRecordClass.ItemGUID] = playerAuctionRecordClass;

                    PlayerAuctionRecordDic[playerAuctionRecordClass.itemGuid] = playerAuctionRecordClass;

                }

                else

                {

                    PlayerAuctionRecordDic.Add(playerAuctionRecordClass.ItemGUID, playerAuctionRecordClass);

                    PlayerAuctionRecordDic.Add(playerAuctionRecordClass.itemGuid, playerAuctionRecordClass);

                }

            }

            if (PlayerAuctionRecordUpdate != null)

@@ -257,7 +243,7 @@
            {

                var AddAuctionItem = info.AddAuctionItemList[i];

                AddAuctionItemInfoClass addAuctionItemInfo = new AddAuctionItemInfoClass();

                addAuctionItemInfo.ItemGUID = AddAuctionItem.ItemGUID;

                addAuctionItemInfo.ItemGUID = UIHelper.ServerStringTrim(AddAuctionItem.ItemGUID);

                addAuctionItemInfo.ItemID = (int)AddAuctionItem.ItemID;

                addAuctionItemInfo.Bool = true;

                if (AddAuctionItemInfoDic.ContainsKey(addAuctionItemInfo.ItemID))

@@ -281,31 +267,29 @@
            for (int i = 0; i < info.AuctionItemCount; i++)

            {

                var FamilyAuctionItem = info.AuctionItemList[i];

                AuctionItemClass familyAuctionItemClass = new AuctionItemClass();

                familyAuctionItemClass.ItemGUID = FamilyAuctionItem.ItemGUID;

                familyAuctionItemClass.FamilyID = (int)FamilyAuctionItem.FamilyID;

                familyAuctionItemClass.ItemID = (int)FamilyAuctionItem.ItemID;

                familyAuctionItemClass.ItemCount = (int)FamilyAuctionItem.ItemCount;

                familyAuctionItemClass.TimeStr = FamilyAuctionItem.AddTime;

                familyAuctionItemClass.Time = DateTime.Parse(FamilyAuctionItem.AddTime);

                AuctionItem familyAuctionItemClass = new AuctionItem();

                familyAuctionItemClass.itemGuid = UIHelper.ServerStringTrim(FamilyAuctionItem.ItemGUID);

                familyAuctionItemClass.familyId = (int)FamilyAuctionItem.FamilyID;

                familyAuctionItemClass.itemId = (int)FamilyAuctionItem.ItemID;

                familyAuctionItemClass.itemCount = (int)FamilyAuctionItem.ItemCount;

                familyAuctionItemClass.putAwayTime = DateTime.Parse(FamilyAuctionItem.AddTime);

                var str = UIHelper.ServerStringTrim(FamilyAuctionItem.BiddingTime);

                if (!str.Equals(string.Empty))

                {

                    familyAuctionItemClass.TimeEnd = DateTime.Parse(str);

                    familyAuctionItemClass.latestBiddingTime = DateTime.Parse(str);

                }

                familyAuctionItemClass.BidderPrice = FamilyAuctionItem.BidderPrice;

                familyAuctionItemClass.UserData = FamilyAuctionItem.UserData;

                familyAuctionItemClass.FamilyPlayerIDInfo = FamilyAuctionItem.FamilyPlayerIDInfo;

                familyAuctionItemClass.FamilyPlayerIDList = new List<int>();

                familyAuctionItemClass.FamilyPlayerIDList = GetFamilyPlayerIDList(FamilyAuctionItem.FamilyPlayerIDInfo);

                familyAuctionItemClass.AuctionType = FamilyAuctionItem.AuctionType;

                if (FamilyAuctionItemDic.ContainsKey(familyAuctionItemClass.ItemGUID))

                familyAuctionItemClass.biddingPrice = FamilyAuctionItem.BidderPrice;

                familyAuctionItemClass.customData = FamilyAuctionItem.UserData;

                familyAuctionItemClass.familyPlayers = new List<int>();

                familyAuctionItemClass.familyPlayers = GetFamilyPlayerIDList(FamilyAuctionItem.FamilyPlayerIDInfo);

                familyAuctionItemClass.auctionType = FamilyAuctionItem.AuctionType;

                if (FamilyAuctionItemDic.ContainsKey(familyAuctionItemClass.itemGuid))

                {

                    FamilyAuctionItemDic[familyAuctionItemClass.ItemGUID] = familyAuctionItemClass;

                    FamilyAuctionItemDic[familyAuctionItemClass.itemGuid] = familyAuctionItemClass;

                }

                else

                {

                    FamilyAuctionItemDic.Add(familyAuctionItemClass.ItemGUID, familyAuctionItemClass);

                    FamilyAuctionItemDic.Add(familyAuctionItemClass.itemGuid, familyAuctionItemClass);

                }

            }

            if (FamilyAuctionItemUpdate != null)

@@ -332,27 +316,26 @@
            for (int i = 0; i < info.AuctionItemCount; i++)

            {

                var AttentionAuctionItem = info.AuctionItemList[i];

                AuctionItemClass playerAuctionItemClass = new AuctionItemClass();

                playerAuctionItemClass.ItemGUID = AttentionAuctionItem.ItemGUID;

                playerAuctionItemClass.FamilyID = (int)AttentionAuctionItem.FamilyID;

                playerAuctionItemClass.ItemID = (int)AttentionAuctionItem.ItemID;

                playerAuctionItemClass.ItemCount = (int)AttentionAuctionItem.ItemCount;

                playerAuctionItemClass.TimeStr = AttentionAuctionItem.AddTime;

                playerAuctionItemClass.Time = DateTime.Parse(AttentionAuctionItem.AddTime);

                AuctionItem playerAuctionItemClass = new AuctionItem();

                playerAuctionItemClass.itemGuid = UIHelper.ServerStringTrim(AttentionAuctionItem.ItemGUID);

                playerAuctionItemClass.familyId = (int)AttentionAuctionItem.FamilyID;

                playerAuctionItemClass.itemId = (int)AttentionAuctionItem.ItemID;

                playerAuctionItemClass.itemCount = (int)AttentionAuctionItem.ItemCount;

                playerAuctionItemClass.putAwayTime = DateTime.Parse(AttentionAuctionItem.AddTime);

                var str = UIHelper.ServerStringTrim(AttentionAuctionItem.BiddingTime);

                if (!str.Equals(string.Empty))

                {

                    playerAuctionItemClass.TimeEnd = DateTime.Parse(str);

                    playerAuctionItemClass.latestBiddingTime = DateTime.Parse(str);

                }

                playerAuctionItemClass.BidderPrice = AttentionAuctionItem.BidderPrice;

                playerAuctionItemClass.UserData = AttentionAuctionItem.UserData;

                if (AttentionAuctionItemDic.ContainsKey(playerAuctionItemClass.ItemGUID))

                playerAuctionItemClass.biddingPrice = AttentionAuctionItem.BidderPrice;

                playerAuctionItemClass.customData = AttentionAuctionItem.UserData;

                if (AttentionAuctionItemDic.ContainsKey(playerAuctionItemClass.itemGuid))

                {

                    AttentionAuctionItemDic[playerAuctionItemClass.ItemGUID] = playerAuctionItemClass;

                    AttentionAuctionItemDic[playerAuctionItemClass.itemGuid] = playerAuctionItemClass;

                }

                else

                {

                    AttentionAuctionItemDic.Add(playerAuctionItemClass.ItemGUID, playerAuctionItemClass);

                    AttentionAuctionItemDic.Add(playerAuctionItemClass.itemGuid, playerAuctionItemClass);

                }

            }

            if (AttentionAuctionItemUdate != null)

@@ -387,69 +370,66 @@
            {

                var RefreshAuctionItem = info.RefreshAuctionItemList[i];



                if (FamilyAuctionItemDic.ContainsKey(RefreshAuctionItem.ItemGUID))// 拍卖行仙盟拍卖中的物品信息

                var guid = UIHelper.ServerStringTrim(RefreshAuctionItem.ItemGUID);



                if (FamilyAuctionItemDic.ContainsKey(guid))// 拍卖行仙盟拍卖中的物品信息

                {

                    var FamilyAuctionItem = FamilyAuctionItemDic[RefreshAuctionItem.ItemGUID];

                    if (FamilyAuctionItem.AuctionType == RefreshAuctionItem.AuctionType)

                    var FamilyAuctionItem = FamilyAuctionItemDic[guid];

                    if (FamilyAuctionItem.auctionType == RefreshAuctionItem.AuctionType)

                    {

                        FamilyAuctionItem.TimeStr = RefreshAuctionItem.AddTime;

                        FamilyAuctionItem.Time = DateTime.Parse(RefreshAuctionItem.AddTime);

                        FamilyAuctionItem.TimeEnd= DateTime.Parse(RefreshAuctionItem.BiddingTime);

                        FamilyAuctionItem.putAwayTime = DateTime.Parse(RefreshAuctionItem.AddTime);

                        FamilyAuctionItem.latestBiddingTime= DateTime.Parse(RefreshAuctionItem.BiddingTime);

                        var str = UIHelper.ServerStringTrim(RefreshAuctionItem.BiddingTime);

                        if (!str.Equals(string.Empty))

                        {

                            FamilyAuctionItem.TimeEnd = DateTime.Parse(str);

                            FamilyAuctionItem.latestBiddingTime = DateTime.Parse(str);

                        }

                        FamilyAuctionItem.BidderID = (int)RefreshAuctionItem.BidderID;

                        FamilyAuctionItem.BidderPrice = (int)RefreshAuctionItem.BidderPrice;

                        FamilyAuctionItemDic[RefreshAuctionItem.ItemGUID] = FamilyAuctionItem;

                        FamilyAuctionItem.biddingPlayer = (int)RefreshAuctionItem.BidderID;

                        FamilyAuctionItem.biddingPrice = (int)RefreshAuctionItem.BidderPrice;

                        FamilyAuctionItemDic[guid] = FamilyAuctionItem;

                    }

                    else

                    {

                        FamilyAuctionItemDic.Remove(RefreshAuctionItem.ItemGUID);

                        FamilyAuctionItemDic.Remove(guid);

                        if (ClearFamilyAuctionUpdate != null)

                        {

                            ClearFamilyAuctionUpdate();

                        }

                    }

                }

                var index = FullServiceAuctionList.FindIndex((x) => { return x.ItemGUID == RefreshAuctionItem.ItemGUID; });

                var index = FullServiceAuctionList.FindIndex((x) => { return x.itemGuid == guid; });

                if (index != -1)//全服拍品

                {

                    FullServiceAuctionList[index].TimeStr = RefreshAuctionItem.AddTime;

                    FullServiceAuctionList[index].Time = DateTime.Parse(RefreshAuctionItem.AddTime);

                    FullServiceAuctionList[index].BidderID = (int)RefreshAuctionItem.BidderID;

                    FullServiceAuctionList[index].BidderPrice = (int)RefreshAuctionItem.BidderPrice;

                    FullServiceAuctionList[index].putAwayTime = DateTime.Parse(RefreshAuctionItem.AddTime);

                    FullServiceAuctionList[index].biddingPlayer = (int)RefreshAuctionItem.BidderID;

                    FullServiceAuctionList[index].biddingPrice = (int)RefreshAuctionItem.BidderPrice;

                }

                if (PlayerAuctionItemInfoDic.ContainsKey(RefreshAuctionItem.ItemGUID))//我的拍品刷新

                if (PlayerAuctionItemInfoDic.ContainsKey(guid))//我的拍品刷新

                {

                    var PlayerAuctionItemInfo = PlayerAuctionItemInfoDic[RefreshAuctionItem.ItemGUID];

                    PlayerAuctionItemInfo.TimeStr = RefreshAuctionItem.AddTime;

                    PlayerAuctionItemInfo.Time = DateTime.Parse(RefreshAuctionItem.AddTime);

                    PlayerAuctionItemInfo.TimeEnd= DateTime.Parse(RefreshAuctionItem.BiddingTime);

                    PlayerAuctionItemInfo.BidderID = (int)RefreshAuctionItem.BidderID;

                    PlayerAuctionItemInfo.BidderPrice = (int)RefreshAuctionItem.BidderPrice;

                    PlayerAuctionItemInfoDic[RefreshAuctionItem.ItemGUID] = PlayerAuctionItemInfo;

                    var PlayerAuctionItemInfo = PlayerAuctionItemInfoDic[guid];

                    PlayerAuctionItemInfo.putAwayTime = DateTime.Parse(RefreshAuctionItem.AddTime);

                    PlayerAuctionItemInfo.latestBiddingTime= DateTime.Parse(RefreshAuctionItem.BiddingTime);

                    PlayerAuctionItemInfo.biddingPlayer = (int)RefreshAuctionItem.BidderID;

                    PlayerAuctionItemInfo.biddingPrice = (int)RefreshAuctionItem.BidderPrice;

                    PlayerAuctionItemInfoDic[guid] = PlayerAuctionItemInfo;

                }

                if (BiddingItemInfoDic.ContainsKey(RefreshAuctionItem.ItemGUID))//玩家竞价中的物品

                if (BiddingItemInfoDic.ContainsKey(guid))//玩家竞价中的物品

                {

                    var biddingItemInfo = BiddingItemInfoDic[RefreshAuctionItem.ItemGUID];

                    biddingItemInfo.TimeStr = RefreshAuctionItem.AddTime;

                    biddingItemInfo.Time = DateTime.Parse(RefreshAuctionItem.AddTime);

                    biddingItemInfo.TimeEnd= DateTime.Parse(RefreshAuctionItem.BiddingTime);

                    biddingItemInfo.BidderID = (int)RefreshAuctionItem.BidderID;

                    biddingItemInfo.BidderPrice = (int)RefreshAuctionItem.BidderPrice;

                    BiddingItemInfoDic[RefreshAuctionItem.ItemGUID] = biddingItemInfo;

                    var biddingItemInfo = BiddingItemInfoDic[guid];

                    biddingItemInfo.putAwayTime = DateTime.Parse(RefreshAuctionItem.AddTime);

                    biddingItemInfo.latestBiddingTime= DateTime.Parse(RefreshAuctionItem.BiddingTime);

                    biddingItemInfo.biddingPlayer = (int)RefreshAuctionItem.BidderID;

                    biddingItemInfo.biddingPrice = (int)RefreshAuctionItem.BidderPrice;

                    BiddingItemInfoDic[guid] = biddingItemInfo;

                }

                if (AttentionAuctionItemDic.ContainsKey(RefreshAuctionItem.ItemGUID))//我关注中的拍品

                if (AttentionAuctionItemDic.ContainsKey(guid))//我关注中的拍品

                {

                    var attentionAuctionItem = AttentionAuctionItemDic[RefreshAuctionItem.ItemGUID];

                    attentionAuctionItem.TimeStr = RefreshAuctionItem.AddTime;

                    attentionAuctionItem.Time = DateTime.Parse(RefreshAuctionItem.AddTime);

                    attentionAuctionItem.TimeEnd = DateTime.Parse(RefreshAuctionItem.BiddingTime);

                    attentionAuctionItem.BidderID = (int)RefreshAuctionItem.BidderID;

                    attentionAuctionItem.BidderPrice = (int)RefreshAuctionItem.BidderPrice;

                    AttentionAuctionItemDic[RefreshAuctionItem.ItemGUID] = attentionAuctionItem;

                    var attentionAuctionItem = AttentionAuctionItemDic[guid];

                    attentionAuctionItem.putAwayTime = DateTime.Parse(RefreshAuctionItem.AddTime);

                    attentionAuctionItem.latestBiddingTime = DateTime.Parse(RefreshAuctionItem.BiddingTime);

                    attentionAuctionItem.biddingPlayer = (int)RefreshAuctionItem.BidderID;

                    attentionAuctionItem.biddingPrice = (int)RefreshAuctionItem.BidderPrice;

                    AttentionAuctionItemDic[guid] = attentionAuctionItem;

                }

                if (RefreshAuctionItemUpdate != null)

                {

@@ -465,26 +445,28 @@
            for (int i = 0; i < info.ClearCount; i++)

            {

                var ItemGUIDList = info.ClearAuctionItemList[i];

                if (BiddingItemInfoDic.ContainsKey(ItemGUIDList.ItemGUID))//清除拍卖行玩家参与竞价中的物品信息 
                var guid = UIHelper.ServerStringTrim(ItemGUIDList.ItemGUID);



                if (BiddingItemInfoDic.ContainsKey(guid))//清除拍卖行玩家参与竞价中的物品信息 
                {

                    BiddingItemInfoDic.Remove(ItemGUIDList.ItemGUID);

                    BiddingItemInfoDic.Remove(guid);

                }

                if (FamilyAuctionItemDic.ContainsKey(ItemGUIDList.ItemGUID))// 清除拍卖行仙盟拍卖中的物品信息

                if (FamilyAuctionItemDic.ContainsKey(guid))// 清除拍卖行仙盟拍卖中的物品信息

                {

                    FamilyAuctionItemDic.Remove(ItemGUIDList.ItemGUID);

                    FamilyAuctionItemDic.Remove(guid);

                    if (ClearFamilyAuctionUpdate != null)

                    {

                        ClearFamilyAuctionUpdate();

                    }

                }

                var index = FullServiceAuctionList.FindIndex((x) => { return x.ItemGUID == ItemGUIDList.ItemGUID; });

                var index = FullServiceAuctionList.FindIndex((x) => { return x.itemGuid == guid; });

                if (index != -1)//清除全服拍品的某一件物品

                {

                    FullServiceAuctionList.RemoveAt(index);

                }

                if (PlayerAuctionItemInfoDic.ContainsKey(ItemGUIDList.ItemGUID))//我的拍品清除

                if (PlayerAuctionItemInfoDic.ContainsKey(guid))//我的拍品清除

                {

                    PlayerAuctionItemInfoDic.Remove(ItemGUIDList.ItemGUID);

                    PlayerAuctionItemInfoDic.Remove(guid);

                }

            }

            if (ClearAuctionUpdate != null)

@@ -499,28 +481,27 @@
            for (int i = 0; i < info.AuctionItemCount; i++)

            {

                var BiddingItem = info.AuctionItemList[i];

                AuctionItemClass BiddingItemClass = new AuctionItemClass();

                BiddingItemClass.ItemGUID = BiddingItem.ItemGUID;

                BiddingItemClass.ItemID = (int)BiddingItem.ItemID;

                BiddingItemClass.ItemCount = BiddingItem.ItemCount;

                BiddingItemClass.FamilyID = (int)BiddingItem.FamilyID;

                BiddingItemClass.TimeStr = BiddingItem.AddTime;

                BiddingItemClass.Time = DateTime.Parse(BiddingItem.AddTime);

                AuctionItem BiddingItemClass = new AuctionItem();

                BiddingItemClass.itemGuid = UIHelper.ServerStringTrim(BiddingItem.ItemGUID);

                BiddingItemClass.itemId = (int)BiddingItem.ItemID;

                BiddingItemClass.itemCount = BiddingItem.ItemCount;

                BiddingItemClass.familyId = (int)BiddingItem.FamilyID;

                BiddingItemClass.putAwayTime = DateTime.Parse(BiddingItem.AddTime);

                var str = UIHelper.ServerStringTrim(BiddingItem.BiddingTime);

                if (!str.Equals(string.Empty))

                {

                    BiddingItemClass.TimeEnd = DateTime.Parse(str);

                    BiddingItemClass.latestBiddingTime = DateTime.Parse(str);

                }

                BiddingItemClass.BidderPrice = BiddingItem.BidderPrice;//竞拍玩家出价

                BiddingItemClass.BidderID = (int)BiddingItem.BidderID;//竞拍玩家ID，也就是当前最高竞价玩家ID

                BiddingItemClass.UserData = BiddingItem.UserData;

                if (BiddingItemInfoDic.ContainsKey(BiddingItemClass.ItemGUID))

                BiddingItemClass.biddingPrice = BiddingItem.BidderPrice;//竞拍玩家出价

                BiddingItemClass.biddingPlayer = (int)BiddingItem.BidderID;//竞拍玩家ID，也就是当前最高竞价玩家ID

                BiddingItemClass.customData = BiddingItem.UserData;

                if (BiddingItemInfoDic.ContainsKey(BiddingItemClass.itemGuid))

                {

                    BiddingItemInfoDic[BiddingItemClass.ItemGUID] = BiddingItemClass;

                    BiddingItemInfoDic[BiddingItemClass.itemGuid] = BiddingItemClass;

                }

                else

                {

                    BiddingItemInfoDic.Add(BiddingItemClass.ItemGUID, BiddingItemClass);

                    BiddingItemInfoDic.Add(BiddingItemClass.itemGuid, BiddingItemClass);

                }

            }

            if (BiddingItemInfoUpdate != null)

@@ -553,7 +534,7 @@
            }

            foreach (var key in FamilyAuctionItemDic.Keys)//判断玩家是否有在竞价仙盟拍品(且是最高价)

            {

                if (BiddingItemInfoDic.ContainsKey(key) && BiddingItemInfoDic[key].BidderID == playerID)

                if (BiddingItemInfoDic.ContainsKey(key) && BiddingItemInfoDic[key].biddingPlayer == playerID)

                {

                    isbool = false;

                }


 System/Auction/FamilyAuctionWin.cs

@@ -17,7 +17,7 @@
        [SerializeField] ScrollerController m_ScrollerControllerItem;

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

        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }
        List<AuctionItemClass> FamilyAuctionList = new List<AuctionItemClass>();
        List<AuctionItem> FamilyAuctionList = new List<AuctionItem>();
        #region Built-in
        protected override void BindController()
        {

@@ -33,6 +33,16 @@
            GetFamilyAuctionItemList();

            ListSotr();

            OnCreateGridCellItem(m_ScrollerControllerItem);

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

             {

                 return x.itemGuid.Equals(AuctionInquiry.Instance.locationGuid);

             });
            if (index != -1)

            {

                m_ScrollerControllerItem.JumpIndex(index);

            }
            AuctionInquiry.Instance.locationGuid = string.Empty;
        }

        protected override void OnAfterOpen()
@@ -81,7 +91,7 @@
        private void OnRefreshGridCellItem(ScrollerDataType type, CellView cell)

        {

            int index = cell.index;

            var ItemGUID = FamilyAuctionList[index].ItemGUID;

            var ItemGUID = FamilyAuctionList[index].itemGuid;

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

            familyAuctionCell.GetFamilyAuctionGUID(ItemGUID);

        }
@@ -93,7 +103,7 @@
            FamilyAuctionList.Clear();

            foreach (var value in model.FamilyAuctionItemDic.Values)

            {

                if (value.AuctionType == 1)

                if (value.auctionType == 1)

                {

                    FamilyAuctionList.Add(value);

                }

@@ -104,22 +114,22 @@
        {

            FamilyAuctionList.Sort(Compare);

        }

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

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

        {

            bool havex = IsHighestPrice(x.ItemGUID);

            bool havey = IsHighestPrice(y.ItemGUID);

            bool havex = IsHighestPrice(x.itemGuid);

            bool havey = IsHighestPrice(y.itemGuid);

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

            {

                return -havex.CompareTo(havey);

            }

            bool havex1 = IsParticipate(x.ItemGUID);

            bool havey1 = IsParticipate(y.ItemGUID);

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

            bool havex2 = IsNeedEquip(x.itemId);

            bool havey2 = IsNeedEquip(y.itemId);

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

            {

                return -havex2.CompareTo(havey2);

@@ -130,8 +140,8 @@
            {

                return -havex3.CompareTo(havey3);

            }

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

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

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

@@ -146,7 +156,7 @@
            if (model.BiddingItemInfoDic.ContainsKey(GUID))

            {

                var biddingItemInfo = model.BiddingItemInfoDic[GUID];

                isBool = biddingItemInfo.BidderID == playerId;

                isBool = biddingItemInfo.biddingPlayer == playerId;

            }

            return isBool;

        }

@@ -174,16 +184,16 @@
            }

            return isBool;

        }
        private int TimeSort(AuctionItemClass auctionItemClass)

        private int TimeSort(AuctionItem auctionItemClass)

        {

            int scends = 0;

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

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

            if (auctionItem == null)

            {

                return 0;

            }

            var timeNow = TimeUtility.ServerNow;

            TimeSpan timeSpan = timeNow - auctionItemClass.Time;

            TimeSpan timeSpan = timeNow - auctionItemClass.putAwayTime;

            scends = (int)timeSpan.TotalSeconds;

            return scends;

        }

 System/Auction/FamilyAuctioncell.cs

@@ -38,7 +38,7 @@
        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }

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

        private AuctionItemConfig AuctionItem;

        private AuctionItemClass FamilyAuctionItem;
        private AuctionItem FamilyAuctionItem;
        public void GetFamilyAuctionGUID(string GUIID)

        {

            m_NeedImage.SetActive(false);

@@ -54,16 +54,16 @@
            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);

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

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

            if (itemConfig == null)

            {

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

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

                return;

            }

            if (auctionItem == null)

            {

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

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

                return;

            }

            AuctionItem = auctionItem;

@@ -77,12 +77,17 @@
            {

                var biddingItemInfo = model.BiddingItemInfoDic[GUIID];

                m_ParticipateImage.SetActive(true);

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

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

                {

                    m_HighestPriceImage.SetActive(true);

                }

            }

            if (familyAuctionItem.BidderPrice != 0)



            if (auctionHelpModel.IsItemWarmUp(familyAuctionItem))

            {

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

            }

            else if (familyAuctionItem.biddingPrice != 0)

            {

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

            }

@@ -90,11 +95,11 @@
            {

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

            }

            ItemCellModel cellModel = new ItemCellModel(familyAuctionItem.ItemID, true, (ulong)familyAuctionItem.ItemCount);

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

            m_ItemCell.Init(cellModel);

            m_ItemCell.button.SetListener(() =>

            {

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

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

                itemTipsModel.SetItemTipsModel(attrData);

            });

            m_ItemName.text = itemConfig.ItemName;

@@ -112,20 +117,20 @@
            }

            int needJade = 0;

            int priceMax = 0;

            priceMax = auctionItem.BuyoutPrice * familyAuctionItem.ItemCount;

            if (familyAuctionItem.BidderPrice == 0)

            priceMax = auctionItem.BuyoutPrice * familyAuctionItem.itemCount;

            if (familyAuctionItem.biddingPrice == 0)

            {

                needJade = auctionItem.BasePrice * familyAuctionItem.ItemCount;

                needJade = auctionItem.BasePrice * familyAuctionItem.itemCount;

            }

            else

            {

                needJade = familyAuctionItem.BidderPrice + auctionItem.BiddingAdd * familyAuctionItem.ItemCount;

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

            }

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

            {

                needJade = priceMax;

            }

            m_JadeNumber.text = familyAuctionItem.BidderPrice.ToString();

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

            m_JadeNumber1.text = priceMax.ToString();

            if (auctionItem.BuyoutPrice == 0)

            {

@@ -180,11 +185,11 @@
            if (AuctionItem != null && FamilyAuctionItem != null)

            {

                var timeNow = TimeUtility.ServerNow;

                TimeSpan timeSpan = timeNow - FamilyAuctionItem.Time;

                TimeSpan timeSpan = timeNow - FamilyAuctionItem.putAwayTime;

                int minute = (int)timeSpan.TotalMinutes;



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

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

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

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

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

                {

                    if (m_PriceButton.interactable)

@@ -223,15 +228,15 @@

        private void SetButtonStatus()

        {

            var maxMoney = AuctionItem.BuyoutPrice * FamilyAuctionItem.ItemCount;

            var maxMoney = AuctionItem.BuyoutPrice * FamilyAuctionItem.itemCount;

            var needMoney = 0;

            if (FamilyAuctionItem.BidderPrice == 0)

            if (FamilyAuctionItem.biddingPrice == 0)

            {

                needMoney = AuctionItem.BasePrice * FamilyAuctionItem.ItemCount;

                needMoney = AuctionItem.BasePrice * FamilyAuctionItem.itemCount;

            }

            else

            {

                needMoney = FamilyAuctionItem.BidderPrice + AuctionItem.BiddingAdd * FamilyAuctionItem.ItemCount;

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

            }

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

            {


 System/Auction/FullServiceAuctionWin.cs

@@ -26,7 +26,7 @@
        [SerializeField] Button m_TypeTipBtn;

        [SerializeField] Text m_JobTipText;

        [SerializeField] Text m_TypeTipText;

        List<AuctionItemClass> FullServiceAuctionListSort = new List<AuctionItemClass>();//全服拍品列表

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

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

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



@@ -270,7 +270,7 @@
                for (int i = 0; i < model.FullServiceAuctionList.Count; i++)

                {

                    var FullServiceAuction = model.FullServiceAuctionList[i];

                    var index = FullServiceAuctionListSort.FindIndex((x) => { return x.ItemGUID == FullServiceAuction.ItemGUID; });

                    var index = FullServiceAuctionListSort.FindIndex((x) => { return x.itemGuid == FullServiceAuction.itemGuid; });

                    if (index == -1)

                    {

                        FullServiceAuctionListSort.Add(FullServiceAuction);

@@ -284,8 +284,8 @@
            gridCtrl.Refresh();

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

            {

                var GUID = FullServiceAuctionListSort[i].ItemGUID;

                var indexList = model.FullServiceAuctionList.FindIndex((x) => { return x.ItemGUID == GUID; });

                var GUID = FullServiceAuctionListSort[i].itemGuid;

                var indexList = model.FullServiceAuctionList.FindIndex((x) => { return x.itemGuid == GUID; });

                if (indexList == -1 && !model.BiddingItemInfoDic.ContainsKey(GUID))//未查找到相应的列表数据(防范)

                {

                    continue;

@@ -298,8 +298,8 @@
        {

            int index = cell.index;

            FullServiceAuctioncell fullServiceAuctioncell = cell.GetComponent<FullServiceAuctioncell>();

            AuctionItemClass auctionItemClass = FullServiceAuctionListSort[index];

            fullServiceAuctioncell.GetFullServiceAuctionGUID(auctionItemClass.ItemGUID, index);

            AuctionItem auctionItemClass = FullServiceAuctionListSort[index];

            fullServiceAuctioncell.GetFullServiceAuctionGUID(auctionItemClass.itemGuid, index);

        }

        private void Reset()//重置查询

@@ -347,11 +347,11 @@
                int num = 0;

                if (sendNumber != 0)

                {

                    var auctionItem = AuctionItemConfig.Get(vlaue.ItemID);

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

                    num = sendNumber / 1000;

                    num -= 1;

                    if (model.FamilyAuctionItemDic.ContainsKey(vlaue.ItemGUID)

                        && model.FamilyAuctionItemDic[vlaue.ItemGUID].AuctionType != 0)//如果存在仙盟拍品且不是全服拍品过滤掉

                    if (model.FamilyAuctionItemDic.ContainsKey(vlaue.itemGuid)

                        && model.FamilyAuctionItemDic[vlaue.itemGuid].auctionType != 0)//如果存在仙盟拍品且不是全服拍品过滤掉

                    {

                        continue;

                    }

@@ -365,16 +365,16 @@
            }

            FullServiceAuctionListSort.Sort(Compare);

        }

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

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

        {

            bool havex = IsHighestPrice(x.ItemGUID);

            bool havey = IsHighestPrice(y.ItemGUID);

            bool havex = IsHighestPrice(x.itemGuid);

            bool havey = IsHighestPrice(y.itemGuid);

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

            {

                return -havex.CompareTo(havey);

            }

            bool havex1 = IsParticipate(x.ItemGUID);

            bool havey1 = IsParticipate(y.ItemGUID);

            bool havex1 = IsParticipate(x.itemGuid);

            bool havey1 = IsParticipate(y.itemGuid);

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

            {

                return -havex1.CompareTo(havey1);

@@ -388,7 +388,7 @@
            if (model.BiddingItemInfoDic.ContainsKey(GUID))

            {

                var biddingItemInfo = model.BiddingItemInfoDic[GUID];

                isBool = biddingItemInfo.BidderID == playerId;

                isBool = biddingItemInfo.biddingPlayer == playerId;

            }

            return isBool;

        }


 System/Auction/FullServiceAuctioncell.cs

@@ -39,7 +39,7 @@
        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }

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

        private AuctionItemConfig AuctionItem;

        private AuctionItemClass FullServiceAuction;

        private AuctionItem FullServiceAuction;



        public void GetFullServiceAuctionGUID(string GUID, int index)

        {

@@ -48,13 +48,13 @@
            m_HighestPriceImage.SetActive(false);

            m_EquipmentScoreObj.SetActive(false);

            m_OverTime.gameObject.SetActive(false);

            var indexList = model.FullServiceAuctionList.FindIndex((x) => { return x.ItemGUID == GUID; });

            var indexList = model.FullServiceAuctionList.FindIndex((x) => { return x.itemGuid == GUID; });

            if (indexList == -1 && !model.BiddingItemInfoDic.ContainsKey(GUID))

            {

                DebugEx.Log("未查找到相应的列表数据");

                return;

            }

            AuctionItemClass fullServiceAuction = new AuctionItemClass();

            AuctionItem fullServiceAuction = new AuctionItem();

            if (indexList != -1)

            {

                fullServiceAuction = model.FullServiceAuctionList[indexList];

@@ -68,7 +68,7 @@
                var sendNumber = AuctionInquiry.Instance.GetSendNumber();

                if (sendNumber != 0 && auctionHelpModel.Wait && model.QueryRemaining.UpBool && !auctionHelpModel.isOpenPanel)

                {

                    AuctionInquiry.Instance.SendQueryAuction(fullServiceAuction.ItemGUID, sendNumber, 2);

                    AuctionInquiry.Instance.SendQueryAuction(fullServiceAuction.itemGuid, sendNumber, 2);

                    auctionHelpModel.Wait = false;

                }

            }

@@ -77,22 +77,22 @@
                var sendNumber = AuctionInquiry.Instance.GetSendNumber();

                if (sendNumber != 0 && auctionHelpModel.Wait && model.QueryRemaining.DownBool && !auctionHelpModel.isOpenPanel)

                {

                    AuctionInquiry.Instance.SendQueryAuction(fullServiceAuction.ItemGUID, sendNumber, 1);

                    AuctionInquiry.Instance.SendQueryAuction(fullServiceAuction.itemGuid, sendNumber, 1);

                    auctionHelpModel.Wait = false;

                }

            }

            FullServiceAuction = fullServiceAuction;

            var playerId = PlayerDatas.Instance.baseData.PlayerID;

            var auctionItem = AuctionItemConfig.Get(fullServiceAuction.ItemID);

            var itemConfig = ItemConfig.Get(fullServiceAuction.ItemID);

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

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

            if (itemConfig == null)

            {

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

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

                return;

            }

            if (auctionItem == null)

            {

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

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

                return;

            }

            AuctionItem = auctionItem;

@@ -102,17 +102,22 @@
            {

                m_NeedImage.SetActive(true);

            }

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

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

            {

                var biddingItemInfo = model.BiddingItemInfoDic[fullServiceAuction.ItemGUID];

                var biddingItemInfo = model.BiddingItemInfoDic[fullServiceAuction.itemGuid];

                m_ParticipateImage.SetActive(true);

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

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

                {

                    m_HighestPriceImage.SetActive(true);

                }



            }

            if (fullServiceAuction.BidderPrice != 0)



            if (auctionHelpModel.IsItemWarmUp(fullServiceAuction))

            {

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

            }

            else if (fullServiceAuction.biddingPrice != 0)

            {

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

            }

@@ -121,11 +126,11 @@
                m_BiddingText.text = Language.Get("PMH_05");

            }



            ItemCellModel cellModel = new ItemCellModel(fullServiceAuction.ItemID, true, (ulong)fullServiceAuction.ItemCount);

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

            m_ItemCell.Init(cellModel);

            m_ItemCell.button.SetListener(() =>

            {

                ItemAttrData attrData = new ItemAttrData(fullServiceAuction.ItemID, true, (ulong)1);

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

                itemTipsModel.SetItemTipsModel(attrData);

            });

            m_ItemName.text = itemConfig.ItemName;

@@ -143,20 +148,20 @@
            }

            int needJade = 0;

            int priceMax = 0;

            priceMax = auctionItem.BuyoutPrice * fullServiceAuction.ItemCount;

            if (fullServiceAuction.BidderPrice == 0)

            priceMax = auctionItem.BuyoutPrice * fullServiceAuction.itemCount;

            if (fullServiceAuction.biddingPrice == 0)

            {

                needJade = auctionItem.BasePrice * fullServiceAuction.ItemCount;

                needJade = auctionItem.BasePrice * fullServiceAuction.itemCount;

            }

            else

            {

                needJade = fullServiceAuction.BidderPrice + auctionItem.BiddingAdd * fullServiceAuction.ItemCount;

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

            }

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

            {

                needJade = priceMax;

            }

            m_JadeNumber.text = fullServiceAuction.BidderPrice.ToString();

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

            m_JadeNumber1.text = priceMax.ToString();

            if (auctionItem.BuyoutPrice == 0)

            {

@@ -176,7 +181,7 @@
                    {

                        if (jade >= priceMax)

                        {

                            AuctionInquiry.Instance.SendSellAuctionItem(fullServiceAuction.ItemGUID, priceMax);

                            AuctionInquiry.Instance.SendSellAuctionItem(fullServiceAuction.itemGuid, priceMax);

                        }

                        else

                        {

@@ -196,7 +201,7 @@
                    {

                        if (jade >= needJade)

                        {

                            AuctionInquiry.Instance.SendSellAuctionItem(fullServiceAuction.ItemGUID, needJade);

                            AuctionInquiry.Instance.SendSellAuctionItem(fullServiceAuction.itemGuid, needJade);

                        }

                        else

                        {

@@ -212,11 +217,11 @@
            if (AuctionItem != null && FullServiceAuction != null)

            {

                var timeNow = TimeUtility.ServerNow;

                TimeSpan timeSpan = timeNow - FullServiceAuction.Time;

                TimeSpan timeSpan = timeNow - FullServiceAuction.putAwayTime;

                int minute = (int)timeSpan.TotalMinutes;



                DateTime overTime = FullServiceAuction.Time.AddMinutes(AuctionItem.FamilySaleMinutes + AuctionItem.NoticeSaleMinutes);

                DateTime extensionTime = FullServiceAuction.TimeEnd.AddSeconds(auctionHelpModel.ExtensionTime);

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

                DateTime extensionTime = FullServiceAuction.latestBiddingTime.AddSeconds(auctionHelpModel.ExtensionTime);

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

                {

                    if (m_PriceButton.interactable)

@@ -256,15 +261,15 @@


        private void SetButtonStatus()

        {

            var maxMoney = AuctionItem.BuyoutPrice * FullServiceAuction.ItemCount;

            var maxMoney = AuctionItem.BuyoutPrice * FullServiceAuction.itemCount;

            var needMoney = 0;

            if (FullServiceAuction.BidderPrice == 0)

            if (FullServiceAuction.biddingPrice == 0)

            {

                needMoney = AuctionItem.BasePrice * FullServiceAuction.ItemCount;

                needMoney = AuctionItem.BasePrice * FullServiceAuction.itemCount;

            }

            else

            {

                needMoney = FullServiceAuction.BidderPrice + AuctionItem.BiddingAdd * FullServiceAuction.ItemCount;

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

            }

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

            {


 System/Auction/MyAuctionCell.cs

@@ -31,7 +31,7 @@
        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }

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

        private AuctionItemConfig AuctionItem;

        private AuctionItemClass MyAuction;

        private AuctionItem MyAuction;

        public void GetMyAuctionGUID(string GUIID)

        {

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

@@ -42,7 +42,7 @@
            m_MyAuction.SetActive(false);

            m_FamilyImage.SetActive(false);

            m_OverTime.gameObject.SetActive(false);

            AuctionItemClass myAuction = new AuctionItemClass();

            AuctionItem myAuction = new AuctionItem();

            int type = 0;//0自身上架，1仙盟上架

            if (model.PlayerAuctionItemInfoDic.ContainsKey(GUIID))

            {

@@ -56,58 +56,54 @@
                m_FamilyImage.SetActive(true);

                myAuction = model.FamilyAuctionItemDic[GUIID];

            }

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

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

            MyAuction = myAuction;

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

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

            if (itemConfig == null)

            {

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

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

                return;

            }

            if (auctionItem == null)

            {

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

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

                return;

            }

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

            AuctionItem = auctionItem;

            m_Income.text = 0.ToString();

            if (myAuction.BidderPrice == 0)

            {

                if (type == 0)

                {

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

                }

                else if (type == 1)

                {

                    if (myAuction.AuctionType == 0)//是否仙盟拍品流拍至全服拍品

                    {

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

                    }

                    else

                    {

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

                    }



                }

            bool isWarmUp = auctionHelpModel.IsItemWarmUp(myAuction);



            if (isWarmUp)

            {

                m_BiddingText.text = Language.Get(myAuction.auctionType == 0 ? "PMH_07" : "PMH_17");

            }

            else if (myAuction.biddingPrice == 0)

            {

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

            }

            else

            {

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

            }



            if (myAuction.biddingPrice != 0)

            {

                if (type == 0)

                {

                    int auctionTaxrate = Mathf.FloorToInt((float)(auctionHelpModel.

                        AuctionTaxrate1 * myAuction.BidderPrice) / 100);//个人税收

                    int incomeNumber = myAuction.BidderPrice - auctionTaxrate;

                        AuctionTaxrate1 * myAuction.biddingPrice) / 100);//个人税收

                    int incomeNumber = myAuction.biddingPrice - auctionTaxrate;

                    m_Income.text = incomeNumber.ToString();

                }

                else if (type == 1)

                {

                    int auctionTaxrate = Mathf.FloorToInt((float)(auctionHelpModel.

                       AuctionTaxrate2 * myAuction.BidderPrice) / 100);//仙盟税收

                    int number = myAuction.BidderPrice - auctionTaxrate;

                       AuctionTaxrate2 * myAuction.biddingPrice) / 100);//仙盟税收

                    int number = myAuction.biddingPrice - auctionTaxrate;

                    int incomeMax = Mathf.CeilToInt((float)(number * auctionHelpModel.AuctionTaxrate3) / 100);

                    int incomeNumber = Mathf.CeilToInt((float)number / myAuction.FamilyPlayerIDList.Count);

                    int incomeNumber = Mathf.CeilToInt((float)number / myAuction.familyPlayers.Count);

                    if (incomeMax >= incomeNumber)

                    {

                        m_Income.text = incomeNumber.ToString();

@@ -117,13 +113,14 @@
                        m_Income.text = incomeMax.ToString();

                    }

                }



            }

            ItemCellModel cellModel = new ItemCellModel(myAuction.ItemID, true, (ulong)myAuction.ItemCount);





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

            m_ItemCell.Init(cellModel);

            m_ItemCell.button.SetListener(() =>

            {

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

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

                itemTipsModel.SetItemTipsModel(attrData);

            });

            m_ItemName.text = itemConfig.ItemName;

@@ -139,9 +136,9 @@
            {

                m_EquipmentScoreObj.SetActive(false);

            }

            if (myAuction.BidderPrice != 0)

            if (myAuction.biddingPrice != 0)

            {

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

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

            }

            else

            {

@@ -155,11 +152,11 @@
            if (AuctionItem != null && MyAuction != null)

            {

                var timeNow = TimeUtility.ServerNow;

                TimeSpan timeSpan = timeNow - MyAuction.Time;

                TimeSpan timeSpan = timeNow - MyAuction.putAwayTime;

                int minute = (int)timeSpan.TotalMinutes;



                DateTime overTime = MyAuction.Time.AddMinutes(AuctionItem.FamilySaleMinutes + AuctionItem.NoticeSaleMinutes);

                DateTime extensionTime = MyAuction.TimeEnd.AddSeconds(auctionHelpModel.ExtensionTime);

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

                DateTime extensionTime = MyAuction.latestBiddingTime.AddSeconds(auctionHelpModel.ExtensionTime);

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

                {

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


 System/Auction/MyAuctionWin.cs

@@ -16,7 +16,7 @@
        [SerializeField] ScrollerController m_ScrollerController;

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

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

        List<AuctionItemClass> PlayerAuctionItemList = new List<AuctionItemClass>();
        List<AuctionItem> PlayerAuctionItemList = new List<AuctionItem>();
        #region Built-in
        protected override void BindController()
        {

@@ -83,7 +83,7 @@
        {



            int index = cell.index;

            var ItemGUID = PlayerAuctionItemList[index].ItemGUID;

            var ItemGUID = PlayerAuctionItemList[index].itemGuid;

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

            myAuctionCell.GetMyAuctionGUID(ItemGUID);

        }
@@ -99,9 +99,9 @@
            int playerID = (int)PlayerDatas.Instance.baseData.PlayerID;

            foreach (var value in model.FamilyAuctionItemDic.Values)

            {

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

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

                {

                    int familyPlayerID = value.FamilyPlayerIDList[i];

                    int familyPlayerID = value.familyPlayers[i];

                    if (familyPlayerID == playerID)

                    {

                        PlayerAuctionItemList.Add(value);

@@ -113,34 +113,34 @@
        {

            PlayerAuctionItemList.Sort(Compare);

        }

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

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

        {

            bool havex = model.PlayerAuctionItemInfoDic.ContainsKey(x.ItemGUID);

            bool havey = model.PlayerAuctionItemInfoDic.ContainsKey(y.ItemGUID); ;

            bool havex = model.PlayerAuctionItemInfoDic.ContainsKey(x.itemGuid);

            bool havey = model.PlayerAuctionItemInfoDic.ContainsKey(y.itemGuid); ;

            if (havex.CompareTo(havey) != 0)//是否为全服拍品

            {

                return -havex.CompareTo(havey);

            }

            bool havex1 = x.BidderPrice != 0;

            bool havey1 = y.BidderPrice != 0;

            bool havex1 = x.biddingPrice != 0;

            bool havey1 = y.biddingPrice != 0;

            if (havex1.CompareTo(havey1) != 0)//是否有收益

            {

                return -havex1.CompareTo(havey1);

            }

            bool havex2 = model.FamilyAuctionItemDic.ContainsKey(x.ItemGUID);

            bool havey2 = model.FamilyAuctionItemDic.ContainsKey(y.ItemGUID);

            bool havex2 = model.FamilyAuctionItemDic.ContainsKey(x.itemGuid);

            bool havey2 = model.FamilyAuctionItemDic.ContainsKey(y.itemGuid);

            if (havex2.CompareTo(havey2) != 0)//是否为仙盟拍品

            {

                return -havex2.CompareTo(havey2);

            }

            bool havex3 = x.BidderPrice != 0;

            bool havey3 = y.BidderPrice != 0;

            bool havex3 = x.biddingPrice != 0;

            bool havey3 = y.biddingPrice != 0;

            if (havex3.CompareTo(havey3) != 0)//是否有收益

            {

                return -havex3.CompareTo(havey3);

            }

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

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

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


 System/Auction/MyFocusCell.cs

@@ -37,7 +37,7 @@
        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }

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

        private AuctionItemConfig AuctionItem;

        private AuctionItemClass MyFocusItem;

        private AuctionItem MyFocusItem;

        public void GetMyFocusGUID(string GUIID)

        {

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

@@ -50,7 +50,7 @@
            m_HighestPriceImage.SetActive(false);

            m_EquipmentScoreObj.SetActive(false);

            m_OverTime.gameObject.SetActive(false);

            AuctionItemClass myAuction = new AuctionItemClass();

            AuctionItem myAuction = new AuctionItem();

            int type = 0;

            if (model.AttentionAuctionItemDic.ContainsKey(GUIID))

            {

@@ -64,16 +64,16 @@
            }

            MyFocusItem = myAuction;

            var playerId = PlayerDatas.Instance.baseData.PlayerID;

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

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

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

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

            if (itemConfig == null)

            {

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

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

                return;

            }

            if (auctionItem == null)

            {

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

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

                return;

            }

            AuctionItem = auctionItem;

@@ -87,7 +87,7 @@
            {

                var biddingItemInfo = model.BiddingItemInfoDic[GUIID];

                m_ParticipateImage.SetActive(true);

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

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

                {

                    m_HighestPriceImage.SetActive(true);

                }

@@ -97,7 +97,11 @@


                }

            }

            if (myAuction.BidderPrice != 0)

            if (auctionHelpModel.IsItemWarmUp(myAuction))

            {

                m_BiddingText.text = Language.Get(myAuction.auctionType == 0 ? "PMH_07" : "PMH_17");

            }

            else if (myAuction.biddingPrice != 0)

            {

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

            }

@@ -105,11 +109,11 @@
            {

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

            }

            ItemCellModel cellModel = new ItemCellModel(myAuction.ItemID, true, (ulong)myAuction.ItemCount);

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

            m_ItemCell.Init(cellModel);

            m_ItemCell.button.SetListener(() =>

            {

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

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

                itemTipsModel.SetItemTipsModel(attrData);

            });

            m_ItemName.text = itemConfig.ItemName;

@@ -127,22 +131,22 @@
            }

            int needJade = 0;

            int priceMax = 0;

            priceMax = auctionItem.BuyoutPrice * myAuction.ItemCount;

            priceMax = auctionItem.BuyoutPrice * myAuction.itemCount;



            priceMax = auctionItem.BuyoutPrice * myAuction.ItemCount;

            if (myAuction.BidderPrice == 0)

            priceMax = auctionItem.BuyoutPrice * myAuction.itemCount;

            if (myAuction.biddingPrice == 0)

            {

                needJade = auctionItem.BasePrice * myAuction.ItemCount;

                needJade = auctionItem.BasePrice * myAuction.itemCount;

            }

            else

            {

                needJade = myAuction.BidderPrice + auctionItem.BiddingAdd * myAuction.ItemCount;

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

            }

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

            {

                needJade = priceMax;

            }

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

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

            m_JadeNumber1.text = priceMax.ToString();

            if (auctionItem.BuyoutPrice == 0)

            {

@@ -199,11 +203,11 @@
            if (AuctionItem != null && MyFocusItem != null)

            {

                var timeNow = TimeUtility.ServerNow;

                TimeSpan timeSpan = timeNow - MyFocusItem.Time;

                TimeSpan timeSpan = timeNow - MyFocusItem.putAwayTime;

                int minute = (int)timeSpan.TotalMinutes;



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

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

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

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

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

                {

                    if (m_PriceButton.interactable)

@@ -242,15 +246,15 @@

        private void SetButtonStatus()

        {

            var maxMoney = AuctionItem.BuyoutPrice * MyFocusItem.ItemCount;

            var maxMoney = AuctionItem.BuyoutPrice * MyFocusItem.itemCount;

            var needMoney = 0;

            if (MyFocusItem.BidderPrice == 0)

            if (MyFocusItem.biddingPrice == 0)

            {

                needMoney = AuctionItem.BasePrice * MyFocusItem.ItemCount;

                needMoney = AuctionItem.BasePrice * MyFocusItem.itemCount;

            }

            else

            {

                needMoney = MyFocusItem.BidderPrice + AuctionItem.BiddingAdd * MyFocusItem.ItemCount;

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

            }

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

            {


 System/Auction/MyFocusWin.cs

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

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

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

        List<AuctionItemClass> MyFocusList = new List<AuctionItemClass>();
        List<AuctionItem> MyFocusList = new List<AuctionItem>();
        int MaxFocusCount = 0;
        #region Built-in
        protected override void BindController()
@@ -96,7 +96,7 @@
        private void OnRefreshGridCell(ScrollerDataType type, CellView cell)

        {

            int index = cell.index;

            var ItemGUID = MyFocusList[index].ItemGUID;

            var ItemGUID = MyFocusList[index].itemGuid;

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

            myAuctionCell.GetMyFocusGUID(ItemGUID);

        }

@@ -111,7 +111,7 @@
            int playerID = (int)PlayerDatas.Instance.baseData.PlayerID;

            foreach (var value in model.FamilyAuctionItemDic.Values)

            {

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

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

                {

                    MyFocusList.Add(value);

                }

@@ -121,22 +121,22 @@
        {

            MyFocusList.Sort(Compare);

        }

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

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

        {

            bool havex = IsHighestPrice(x.ItemGUID);

            bool havey = IsHighestPrice(y.ItemGUID);

            bool havex = IsHighestPrice(x.itemGuid);

            bool havey = IsHighestPrice(y.itemGuid);

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

            {

                return -havex.CompareTo(havey);

            }

            bool havex1 = IsParticipate(x.ItemGUID);

            bool havey1 = IsParticipate(y.ItemGUID);

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

            bool havex2 = IsNeedEquip(x.itemId);

            bool havey2 = IsNeedEquip(y.itemId);

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

            {

                return -havex2.CompareTo(havey2);

@@ -147,8 +147,8 @@
            {

                return -havex3.CompareTo(havey3);

            }

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

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

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

@@ -163,7 +163,7 @@
            if (model.BiddingItemInfoDic.ContainsKey(GUID))

            {

                var biddingItemInfo = model.BiddingItemInfoDic[GUID];

                isBool = biddingItemInfo.BidderID == playerId;

                isBool = biddingItemInfo.biddingPlayer == playerId;

            }

            return isBool;

        }

@@ -191,16 +191,16 @@
            }

            return isBool;

        }
        private int TimeSort(AuctionItemClass auctionItemClass)

        private int TimeSort(AuctionItem auctionItemClass)

        {

            int scends = 0;

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

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

            if (auctionItem == null)

            {

                return 0;

            }

            var timeNow = TimeUtility.ServerNow;

            TimeSpan timeSpan = timeNow - auctionItemClass.Time;

            TimeSpan timeSpan = timeNow - auctionItemClass.putAwayTime;

            scends = (int)timeSpan.TotalSeconds;

            return scends;

        }

 System/Auction/TransactionRecordWin.cs

@@ -24,7 +24,7 @@
        [SerializeField] GameObject m_TextObj;

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

        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }
        private List<AuctionItemClass> AuctionRecordList = new List<AuctionItemClass>();
        private List<AuctionItem> AuctionRecordList = new List<AuctionItem>();
        ItemTipsModel itemTipsModel { get { return ModelCenter.Instance.GetModel<ItemTipsModel>(); } }
        int AuctionType = 0;
        int MaxCount = 0;
@@ -111,17 +111,17 @@
        {

            int index = cell.index;

            var auctionRecord = AuctionRecordList[index];

            var itemConfig = ItemConfig.Get(auctionRecord.ItemID);

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

            if (itemConfig == null)

            {

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

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

                return;

            }

            ItemCell itemCell = cell.transform.Find("ItemCell1").GetComponent<ItemCell>();

            Text textName = cell.transform.Find("ItemName").GetComponent<Text>();

            RichText transactionStatusText = cell.transform.Find("TransactionStatusText").GetComponent<RichText>();

            Text timeText = cell.transform.Find("TimeText").GetComponent<Text>();

            ItemCellModel cellModel = new ItemCellModel(itemConfig.ID, true, (ulong)auctionRecord.ItemCount);

            ItemCellModel cellModel = new ItemCellModel(itemConfig.ID, true, (ulong)auctionRecord.itemCount);



            GameObject SuccessfulBiddingObj = cell.transform.Find("SuccessfulBiddingObj").gameObject;//竞拍成功(竞拍成功)

            TextEx SuccessfulBiddingText = cell.transform.Find("SuccessfulBiddingObj/SuccessfulBiddingText").GetComponent<TextEx>();

@@ -129,7 +129,7 @@


            GameObject AuctionFailedObj = cell.transform.Find("AuctionFailedObj").gameObject;//竞拍失败

            Text JadeMoney_1 = cell.transform.Find("AuctionFailedObj/JadeMoney").GetComponent<Text>();

            switch (auctionRecord.RecordResult)

            switch (auctionRecord.recordResult)

            {

                case 0://流拍

                    transactionStatusText.gameObject.SetActive(true);

@@ -141,9 +141,9 @@
                    SuccessfulBiddingObj.SetActive(true);

                    transactionStatusText.gameObject.SetActive(false);

                    AuctionFailedObj.SetActive(false);

                    var name = UIHelper.ServerStringTrim(auctionRecord.BidderName);

                    var name = UIHelper.ServerStringTrim(auctionRecord.biddingPlayerName);

                    SuccessfulBiddingText.text = Language.Get("PMH_15", name);

                    JadeMoney.text = auctionRecord.BidderPrice.ToString();

                    JadeMoney.text = auctionRecord.biddingPrice.ToString();

                    break;

                case 2://回收

                    transactionStatusText.gameObject.SetActive(true);

@@ -157,13 +157,13 @@
                    AuctionFailedObj.SetActive(false);

                    string strName = string.Empty;

                    SuccessfulBiddingText.text = Language.Get("PMH_13");

                    JadeMoney.text = auctionRecord.BidderPrice.ToString();

                    JadeMoney.text = auctionRecord.biddingPrice.ToString();

                    break;

                case 4://竞价失败

                    AuctionFailedObj.SetActive(true);

                    SuccessfulBiddingObj.SetActive(false);

                    transactionStatusText.gameObject.SetActive(false);

                    JadeMoney_1.text = auctionRecord.BidderPrice.ToString();

                    JadeMoney_1.text = auctionRecord.biddingPrice.ToString();

                    break;

                case 5://仙盟流拍到全服

                    transactionStatusText.gameObject.SetActive(true);

@@ -176,11 +176,11 @@
            itemCell.Init(cellModel);

            itemCell.button.SetListener(() =>

            {

                ItemAttrData attrData = new ItemAttrData(itemConfig.ID, true, (ulong)auctionRecord.ItemCount);

                ItemAttrData attrData = new ItemAttrData(itemConfig.ID, true, (ulong)auctionRecord.itemCount);

                itemTipsModel.SetItemTipsModel(attrData);

            });

            textName.text = itemConfig.ItemName;

            timeText.text = auctionRecord.TimeStr;

            timeText.text = auctionRecord.putAwayTime.ToString("yyyy-MM-dd HH:mm:ss");

        }



        private void OnCreateGridTypeCell(ScrollerController gridCtrl)

@@ -234,18 +234,18 @@
            AuctionRecordList.Clear();

            foreach (var value in model.PlayerAuctionRecordDic.Values)

            {

                if (value.RecordType == AuctionType)

                if (value.recordType == AuctionType)

                {

                    AuctionRecordList.Add(value);

                }

            }

            AuctionRecordList.Sort(Compare);

        }
        int Compare(AuctionItemClass x, AuctionItemClass y)

        int Compare(AuctionItem x, AuctionItem y)

        {

            if (x.Time.CompareTo(y.Time) != 0)//根据时间排序

            if (x.putAwayTime.CompareTo(y.putAwayTime) != 0)//根据时间排序

            {

                return -x.Time.CompareTo(y.Time);

                return -x.putAwayTime.CompareTo(y.putAwayTime);

            }

            return 1;

        }

 System/EquipGem/EquipEvolutionWin.cs

@@ -25,7 +25,6 @@
        [SerializeField] RichText m_TextAttributesA;
        [SerializeField] RichText m_TextAttributesB;
        [SerializeField] ItemCell m_ItemCell;

        [SerializeField] RichText m_ItemCount;



        [SerializeField] GameObject m_AdvancedObj;

        [SerializeField] GameObject m_FullLevelObj;

@@ -132,7 +131,8 @@
            }

            m_TextAttributesA.text = Language.Get("ZBQH_05", strEquipLevel);

            m_TextAttributesB.text = Language.Get("ZBQH_06", strItemCount);

            m_ItemCount.text = strNeedItemCount;

            m_ItemCell.countText.gameObject.SetActive(true);

            m_ItemCell.countText.text = strNeedItemCount;

        }
        private void FullLevel(int advancedLv)

        {