public static MarketResponse getShopDataTest(Category cat)
{
MarketResponse res = new MarketResponse();
for (int i = 0; i < 30; i++)
{
MarketItemMsg item = new MarketItemMsg();
item.SellId = 1000 + i;
item.Id = 100 + i;
item.CostType = CostType.CostCash;
item.SellCount = Random.Range(0, 50);
item.Cost = Random.Range(0, 1000000);
item.BuyLimit = 10 + i;
if (i % 4 != 0)
{
float zz = (float)(i + 1) / 100f;
item.DiscountInfo = new DiscountInfo();
item.DiscountInfo.Discount = i + 1; //string.Format("{0}%", (i + 1));
item.DiscountInfo.DiscountCost = (int)(item.Cost * zz);
}
else
{
item.DiscountInfo = null;
}
res.MarketItems.Add(item);
}
res.Category = cat;
if (cat == Category.Black)
{
res.MarketBlack = new MarketBlack();
res.MarketBlack.FreshCost = 100;
res.MarketBlack.FreshLimit = 3;
}
return(res);
}
public void UndercutAllThoseHoes()
{
var retainerMarketItems = GameHandler.InventoryHandler.Inventory[(int)(Inventory.BagType.Retainer_Market)].Values;
Queue <Item> queue = new Queue <Item>(retainerMarketItems);
MarketResponse response = null;
response = (marketList, historyList) =>
{
Item currentSale = queue.Dequeue();
MarketBoardDataForItem.MarketListing lowest = marketList.Where(i => i.hq == currentSale.IsHQ && i.price > 0).OrderBy(i => i.price).FirstOrDefault();
if (lowest.price != 0)
{
SetRetainerPrice(currentSale.Slot, lowest.price - 1);
}
if (queue.Count > 0)
{
Thread.Sleep(3000);
GetMarketBoardPriceTablesForItem(queue.First().ItemId, response);
}
else
{
this.marketResponse = null;
}
};
if (queue.Count > 0)
{
GetMarketBoardPriceTablesForItem(queue.First().ItemId, response);
}
}
public static void TransPanel(object s)
{
if (s is SCPlayerPropResponse)
{
//var data = s as SCPlayerPropResponse;
//GlobalInfo.MY_PLAYER_INFO.SetBagInfos(data.PlayerProps);
//GlobalInfo.MY_PLAYER_INFO.SetRecentPropInfos(data.RecentProps);
//if (m_CurrentBtn == UIDefine.UI_BAG)
//{
// FrameMgr.OpenUIParams param = new FrameMgr.OpenUIParams(UIDefine.UI_BAG);
// param.Param = s;
// EngineCoreEvents.UIEvent.ShowUIEventWithParam.SafeInvoke(param);
//}
}
else if (s is MarketResponse)
{
MessageHandler.UnRegisterMessageHandler(MessageDefine.MarketResponse, GameEntryHelper.TransPanel);
MarketResponse res = (MarketResponse)s;
if (res.Category == Category.Common)
{
ShopHelper.openShop(res);
}
}
else if (s is SCFriendResponse)
{
var rsp = (SCFriendResponse)s;
if (FriendReqType.Added == rsp.Type)
{
}
}
}
private static void SetQualityStat(MarketResponse marketResponse, ref MarketQualityObject marketQualityObject)
{
if (marketQualityObject == null)
{
return;
}
switch (ItemController.GetQuality(marketResponse.QualityLevel))
{
case FrequentlyValues.ItemQuality.Normal:
marketQualityObject.SellPriceMinNormal = marketResponse.SellPriceMin;
marketQualityObject.SellPriceMinNormalDate = marketResponse.SellPriceMinDate;
return;
case FrequentlyValues.ItemQuality.Good:
marketQualityObject.SellPriceMinGood = marketResponse.SellPriceMin;
marketQualityObject.SellPriceMinGoodDate = marketResponse.SellPriceMinDate;
return;
case FrequentlyValues.ItemQuality.Outstanding:
marketQualityObject.SellPriceMinOutstanding = marketResponse.SellPriceMin;
marketQualityObject.SellPriceMinOutstandingDate = marketResponse.SellPriceMinDate;
return;
case FrequentlyValues.ItemQuality.Excellent:
marketQualityObject.SellPriceMinExcellent = marketResponse.SellPriceMin;
marketQualityObject.SellPriceMinExcellentDate = marketResponse.SellPriceMinDate;
return;
case FrequentlyValues.ItemQuality.Masterpiece:
marketQualityObject.SellPriceMinMasterpiece = marketResponse.SellPriceMin;
marketQualityObject.SellPriceMinMasterpieceDate = marketResponse.SellPriceMinDate;
return;
}
}
public MarketResponse GetMarketResponse(string item, int start, int amount)
{
string marketUrl = GetMarketUrl(item, start, amount);
var response = HttpGet(marketUrl);
dynamic jsonObject = JsonConvert.DeserializeObject(response);
MarketResponse mResp = new MarketResponse();
mResp.AmountTotal = jsonObject.total_count;
mResp.Name = item;
mResp.Size = jsonObject.pagesize;
mResp.Start = jsonObject.start;
List <ListingInfo> listings = new List <ListingInfo>();
var listingInfosJson = jsonObject.listinginfo;
foreach (var listingInfoJson in listingInfosJson)
{
ListingInfo newListing = new ListingInfo();
newListing.Name = item;
newListing.ListingId = listingInfoJson.Name;
newListing.InternalId = listingInfoJson.Value.asset.id;
newListing.InspectLink = listingInfoJson.Value.asset.market_actions[0].link;
newListing.SubTotal = listingInfoJson.Value.converted_price - listingInfoJson.Value.converted_fee;
listings.Add(newListing);
}
mResp.Listings = listings;
return(mResp);
}
static void LoadShopData(object obj)
{
if (obj is MarketResponse)
{
MarketResponse shopdata = obj as MarketResponse;
getShopData(shopdata);
}
}
public static void openShop(MarketResponse shopdata)
{
ShopPropData propData = getShopData(shopdata);
FrameMgr.OpenUIParams param = new FrameMgr.OpenUIParams(UIDefine.UI_SHOP);
param.Param = propData;
EngineCoreEvents.UIEvent.ShowUIEventWithParam.SafeInvoke(param);
}
private void requestData()
{
#if Test
MarketResponse res = ShopHelper.getShopDataTest(cate);
OnResponse(res);
#else
MarketRequest request = new MarketRequest();
request.Category = cate;
GameEvents.NetWorkEvents.SendAsyncMsg.SafeInvoke(request);
#endif
}
public IRuleResult RuleExecuted(Solbot solbot)
{
if (solbot.Strategy.AvailableStrategy.StopLossDown == 0)
{
solbot.Communication.StopLoss = new ChangeMessage
{
Change = 0,
PriceReached = false
};
return(new MarketRuleResult()
{
Success = false,
Message = LogGenerator.Off(MarketOrder)
});
}
else
{
var boughtPrice = solbot.BoughtPrice();
var result = new MarketResponse();
if (boughtPrice > 0)
{
result = _marketService.IsStopLossReached(
solbot.Strategy.AvailableStrategy.CommissionType,
solbot.Strategy.AvailableStrategy.StopLossDown,
boughtPrice,
solbot.Communication.Price.Current);
}
else
{
result.IsReadyForMarket = false;
result.Changed = 0;
}
solbot.Communication.StopLoss = new ChangeMessage
{
Change = result.Changed,
PriceReached = result.IsReadyForMarket
};
var change = solbot.StopLossChange();
return(new MarketRuleResult()
{
Success = result.IsReadyForMarket,
Message = result.Changed < 0
? LogGenerator.StepMarketSuccess(MarketOrder, solbot.Communication.Price.Current, boughtPrice, change)
: LogGenerator.StepMarketError(MarketOrder, solbot.Communication.Price.Current, boughtPrice, change)
});
}
}
private void OnResponse(object msg)
{
if (msg == null)
{
return;
}
if (msg is MarketResponse)
{
MarketResponse res = (MarketResponse)msg;
if (res.Category == Category.Black)
{
m_ChooseEffect.gameObject.transform.SetParent(m_MaskRoot, false);
m_blackdata = ShopHelper.getShopData(res);
m_NeedReflash = true;
System.DateTime dt = CommonTools.TimeStampToDateTime(m_blackdata.m_NextReflashTime);
m_TotalSecond = (float)(dt - System.DateTime.Now).TotalSeconds + 2;
m_curTime = Time.time;
m_tradingTime_lab.Text = CommonTools.SecondToStringDDMMSS(m_TotalSecond);
ReflashShop(m_blackdata);
}
else if (res.Category == Category.Common)
{
m_ChooseEffect.gameObject.transform.SetParent(m_MaskRoot, false);
m_propdata = ShopHelper.getShopData((res));
ReflashShop(m_propdata);
}
}
else if (msg is MarkeFreshResponse)
{
MarkeFreshResponse res = (MarkeFreshResponse)msg;
if (res.ResponseStatus == null)
{
m_ChooseEffect.gameObject.transform.SetParent(m_MaskRoot, false);
GlobalInfo.MY_PLAYER_INFO.ChangeCash(-m_blackdata.m_reflashCost);
MarketResponse shopRes = new MarketResponse();
shopRes.MarketBlack = res.MarketBlack;
shopRes.MarketItems.Clear();
shopRes.MarketItems.Add(res.MarketItems);
shopRes.Category = Category.Black;
m_blackdata = ShopHelper.getShopData(shopRes);
ReflashShop(m_blackdata);
}
else
{
ResponseStatus resStatus = res.ResponseStatus;
PopUpManager.OpenNormalOnePop("shop_limite_times");
}
}
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var boughtPrice = solbot.BoughtPrice();
var result = new MarketResponse();
if (boughtPrice > 0)
{
result = _marketService.IsGoodToSell(
solbot.Strategy.AvailableStrategy.CommissionType,
solbot.Strategy.AvailableStrategy.SellUp,
boughtPrice,
solbot.Communication.Price.Current);
}
else
{
result.IsReadyForMarket = false;
result.Changed = 0;
}
solbot.Communication.Sell = new ChangeMessage
{
Change = result.Changed,
PriceReached = result.IsReadyForMarket
};
var change = solbot.SellChange();
var needed = solbot.NeededSellChange();
var priceUp = (solbot.Strategy.AvailableStrategy.CommissionType == CommissionType.PERCENTAGE && result.Changed > 0) ||
solbot.Strategy.AvailableStrategy.CommissionType == CommissionType.VALUE && result.Changed < 0;
return(new MarketRuleResult()
{
Success = result.IsReadyForMarket,
Message = priceUp
? LogGenerator.SellStepSuccess(
solbot.Strategy.AvailableStrategy.SellType,
solbot.Communication.Price.Current,
boughtPrice,
change)
: LogGenerator.SellStepError(
solbot.Strategy.AvailableStrategy.SellType,
solbot.Communication.Price.Current,
boughtPrice,
change,
needed)
});
}
private IStateResponse SellApples(GameObject player)
{
IStateResponse response = new MarketResponse();
AudioManager.Instance.Play("Sell");
var inventory = player.GetComponent <Inventory>();
if (inventory)
{
inventory.SellApples(ApplePrice);
}
response.Success = true;
return(response);
}
public bool GetMarketBoardPriceTablesForItem(uint itemId, MarketResponse marketResponse)
{
RequestMarketBoardDataForItem marketRequest = new RequestMarketBoardDataForItem();
RequestMarketBoardDataForItem.Data marketRequestData = new RequestMarketBoardDataForItem.Data();
marketRequestData.itemId = itemId;
marketRequestData.unk2 = 2306;
marketRequest.PacketData = marketRequestData;
this.GameHandler.SendPacket(new List <Subpacket>()
{
marketRequest
});
this.marketResponse = marketResponse;
return(true);
}
private async Task SetRealMoneyQualityStat(MarketResponse marketResponse, MarketQualityObject marketQualityObject)
{
if (marketQualityObject == null)
{
return;
}
if (_currentGoldPrice == null)
{
var getGoldPricesObjectList = await ApiController.GetGoldPricesFromJsonAsync(null, 1);
_currentGoldPrice = getGoldPricesObjectList?.FirstOrDefault();
}
switch (ItemController.GetQuality(marketResponse.QualityLevel))
{
case ItemQuality.Normal:
marketQualityObject.SellPriceMinNormalStringInRalMoney =
Converter.GoldToDollar(marketResponse.SellPriceMin, _currentGoldPrice?.Price ?? 0);
marketQualityObject.SellPriceMinNormalDate = marketResponse.SellPriceMinDate;
return;
case ItemQuality.Good:
marketQualityObject.SellPriceMinGoodStringInRalMoney =
Converter.GoldToDollar(marketResponse.SellPriceMin, _currentGoldPrice?.Price ?? 0);
marketQualityObject.SellPriceMinGoodDate = marketResponse.SellPriceMinDate;
return;
case ItemQuality.Outstanding:
marketQualityObject.SellPriceMinOutstandingStringInRalMoney =
Converter.GoldToDollar(marketResponse.SellPriceMin, _currentGoldPrice?.Price ?? 0);
marketQualityObject.SellPriceMinOutstandingDate = marketResponse.SellPriceMinDate;
return;
case ItemQuality.Excellent:
marketQualityObject.SellPriceMinExcellentStringInRalMoney =
Converter.GoldToDollar(marketResponse.SellPriceMin, _currentGoldPrice?.Price ?? 0);
marketQualityObject.SellPriceMinExcellentDate = marketResponse.SellPriceMinDate;
return;
case ItemQuality.Masterpiece:
marketQualityObject.SellPriceMinMasterpieceStringInRalMoney =
Converter.GoldToDollar(marketResponse.SellPriceMin, _currentGoldPrice?.Price ?? 0);
marketQualityObject.SellPriceMinMasterpieceDate = marketResponse.SellPriceMinDate;
return;
}
}
public async Task <MarketResponse> GetMarketAsync(MarketRequest request)
{
if (String.IsNullOrEmpty(request.Pair))
{
throw new ArgumentNullException(nameof(request.Pair));
}
var content = await CallAsync <dynamic>(HttpMethod.Get, BuildUrl(_settings.PublicUrl, $"GetMarket/{request.Pair}"));
var response = new MarketResponse
{
AskPrice = content.Data.AskPrice,
BidPrice = content.Data.BidPrice,
High = content.Data.High,
Low = content.Data.Low,
LastPrice = content.Data.LastPrice,
Volume = content.Data.Volume
};
return(response);
}
public IRuleResult RuleExecuted(Solbot solbot)
{
var boughtPrice = solbot.BoughtPrice();
var result = new MarketResponse();
if (boughtPrice > 0)
{
result = _marketService.IsGoodToSell(
solbot.Strategy.AvailableStrategy.CommissionType,
solbot.Strategy.AvailableStrategy.SellUp,
boughtPrice,
solbot.Communication.Price.Current);
}
else
{
result.IsReadyForMarket = false;
result.Changed = 0;
}
solbot.Communication.Sell = new ChangeMessage
{
Change = result.Changed,
PriceReached = result.IsReadyForMarket
};
var change = solbot.SellChange();
return(new MarketRuleResult()
{
Success = result.IsReadyForMarket,
Message = result.Changed > 0
? LogGenerator.StepMarketSuccess(MarketOrder, solbot.Communication.Price.Current, boughtPrice, change)
: LogGenerator.StepMarketError(MarketOrder, solbot.Communication.Price.Current, boughtPrice, change)
});
}
public AlertInfos(Item item, MarketResponse marketResponse)
{
Item = item;
MarketResponse = marketResponse;
}
public static ShopPropData getShopData(MarketResponse shopdata)
{
if (shopdata == null)
{
return(null);
}
ShopPropData pdata = new ShopPropData();
pdata.m_itemdata = new List <ShopItemData>();
List <ShopItemData> m_giftData = new List <ShopItemData>(); //礼盒
if (shopdata.Category == Category.Black && shopdata.MarketBlack != null)
{
pdata.m_reflashCost = shopdata.MarketBlack.FreshCost;
pdata.m_reflashCount = shopdata.MarketBlack.FreshLimit;
pdata.m_LastReflashTime = shopdata.MarketBlack.LastUpdateTime * 10000;
pdata.m_NextReflashTime = shopdata.MarketBlack.NextUpdateTime * 10000;
}
for (int i = 0; i < shopdata.MarketItems.Count; i++)
{
ShopItemData itemdata = new ShopItemData();
MarketItemMsg markitem = shopdata.MarketItems[i];
if (markitem != null)
{
ConfProp prop = ConfProp.Get(markitem.SellId);
itemdata.m_number = markitem.SellCount;
itemdata.marketID = markitem.Id;
itemdata.m_oriPrice = markitem.Cost;
itemdata.m_limitNumber = markitem.BuyLimit;
itemdata.m_maxNumber = markitem.MaxLimit;
itemdata.m_costType = markitem.CostType;
if (markitem.DiscountInfo != null)
{
System.DateTime startTime = CommonTools.TimeStampToDateTime(markitem.DiscountInfo.DiscountStart * 10000);
System.DateTime endTime = CommonTools.TimeStampToDateTime(markitem.DiscountInfo.DiscountEnd * 10000);
System.DateTime nowTime = CommonTools.GetCurrentTime();
if (markitem.DiscountInfo.Discount == 0 || nowTime < startTime || nowTime > endTime)
{
itemdata.m_hasDis = false;
}
else
{
itemdata.m_hasDis = true;
itemdata.m_disPrice = markitem.DiscountInfo.DiscountCost;
itemdata.m_disCount = markitem.DiscountInfo.Discount;
itemdata.m_disIcon = markitem.DiscountInfo.DiscountIcon;
}
}
else
{
itemdata.m_hasDis = false;
}
if (prop != null)
{
itemdata.m_prop = prop;
//todo 临时修改礼盒最前面
if (itemdata.m_prop.type == (int)PROP_TYPE.E_GIFT)
{
m_giftData.Add(itemdata);
}
else
{
pdata.m_itemdata.Add(itemdata);
}
}
else
{
Debug.LogError("item id is not exist:" + markitem.SellId);
}
}
}
pdata.m_itemdata.InsertRange(0, m_giftData);
ShopDataCache[shopdata.Category] = pdata;
return(pdata);
}
