public void Purchase(int marketIndex, MarketProduct marketProduct, int amount)
{
bool hasMoney = GameManager.Inventory.Money >= marketProduct.basePurchasePrice * amount;
bool marketHasEnough = marketProduct.offer - GetPurchaseAmount(marketIndex, marketProduct) >= amount;
bool isAboveMinimumPurchaseAmount = amount >= marketProduct.minimumPurchaseAmount;
if (!hasMoney)
{
Log.Msg("you do not have enough money :(", LogType.Warning);
}
if (!marketHasEnough)
{
Log.Msg("market does not have this amount on sale", LogType.Warning);
}
if (!isAboveMinimumPurchaseAmount)
{
Log.Msg("this market has a minimum sale amount of " + marketProduct.minimumPurchaseAmount, LogType.Warning);
}
if (!hasMoney || !marketHasEnough || !isAboveMinimumPurchaseAmount)
{
return;
}
GameManager.Inventory.AddMoney(-marketProduct.basePurchasePrice * amount);
GameManager.Inventory.AddItemSupply(marketProduct.product, amount);
AddPurchase(marketIndex, marketProduct, amount);
if (onPurchase != null)
{
onPurchase.Invoke(marketIndex, marketProduct, amount);
}
}
public void Sell(int marketIndex, MarketProduct marketProduct, int amount)
{
bool isOnDemand = marketProduct.demand - GetSalesAmount(marketIndex, marketProduct) >= amount;
bool isAboveMinimumSellAmount = amount >= marketProduct.minimumSaleAmount;
bool hasEnoughToSell = amount <= GameManager.Inventory.GetItemFinalProductAmount(marketProduct.product);
if (!isOnDemand)
{
Log.Msg("The market dont want to buy this much", LogType.Warning);
}
if (!isAboveMinimumSellAmount)
{
Log.Msg("The market has a minimum of " + marketProduct.minimumSaleAmount + " items per transaction", LogType.Warning);
}
if (!hasEnoughToSell)
{
Log.Msg("You dont have this much in stock", LogType.Warning);
}
if (!isOnDemand || !isAboveMinimumSellAmount || !hasEnoughToSell)
{
return;
}
GameManager.Inventory.AddMoney(marketProduct.baseSellingPrice * amount);
GameManager.Inventory.RemoveItemFinalProduct(marketProduct.product, amount);
AddSale(marketIndex, marketProduct, amount);
if (onSell != null)
{
onSell.Invoke(marketIndex, marketProduct, amount);
}
}
/// <summary>
/// Receiving a product data struct to display info in template
/// </summary>
/// <param name="product"></param>
public void SetProduct(MarketProduct product)
{
_product = product;
_priceText.text = _product.price.ToString();
_attack.text = product.product.attack_descriptor.ToString();
_speed.text = product.product.speed_descriptor.ToString();
if (_attack.text == "Support" || _speed.text == "Support")
{
_support.SetActive(true);
_stats.SetActive(false);
}
else
{
_stats.SetActive(true);
_support.SetActive(false);
}
// Tower image
Tower tower = _product.product;
if (tower != null && tower.thumbnail != null)
{
_image.sprite = tower.thumbnail;
}
// Apply tint to self for now
GetComponent <Image>().color = rarityColor[_product.rarity];
}
public MarketProduct GetDetail([FromUri] int id)
{
MarketProduct product = _goodsService.GetProductDetail(id);
product.Product.Image.ImageUrl = ImageManager.UrlToHtmlValid(product.Product.Image.ImageUrl);
return(product);
}
public int GetPurchasesAmount(MarketProduct marketProduct)
{
if (purchases.ContainsKey(marketProduct))
{
return(purchases[marketProduct]);
}
return(0);
}
public int GetSalesAmount(MarketProduct marketProduct)
{
if (sales.ContainsKey(marketProduct))
{
return(sales[marketProduct]);
}
return(0);
}
public void deleteProduct(int productId)
{
MarketProduct mProduct = _goodsRepository.GetById(productId);
mProduct.IsDeleted = true;
mProduct.DeletedAt = DateTime.UtcNow;
mProduct = _goodsRepository.Update(mProduct);
}
private void UpdateOffer(int marketIndex, MarketProduct marketProduct, int amount)
{
if (marketIndex == this.marketIndex &&
marketProduct == this.marketProduct)
{
int purchasedAmount = GameManager.Market.GetPurchaseAmount(marketIndex, marketProduct);
int offer = marketProduct.offer - purchasedAmount;
this.offer.text = offer.ToString();
}
}
public void SetItemInfo(MarketProduct product, int marketIndex)
{
this.marketIndex = marketIndex;
this.marketProduct = product;
icon.sprite = product.product.icon;
textName.text = product.product.name;
buyButton.onClick.AddListener(BuyItem);
sellButton.onClick.AddListener(SellItem);
popUp.SetItemInfo(product, marketIndex);
}
public void AddSale(MarketProduct marketProduct, int amount)
{
if (!sales.ContainsKey(marketProduct))
{
sales.Add(marketProduct, amount);
}
else
{
sales[marketProduct] += amount;
}
}
/// <summary>
/// Generate 3 new towers products that can be available.
/// </summary>
public void GenerateTowersList()
{
_products = new List <MarketProduct>();
for (int i = 0; i < 3; i++)
{
int index = GetTowerLevel();
int tiersTowerRandom = Random.Range(0, tiers[index].towers.Count);
MarketProduct p = new MarketProduct(tiers[index].towers[tiersTowerRandom], index, tiers[index].price);
_products.Add(p);
}
}
public void AddPurchase(MarketProduct marketProduct, int amount)
{
if (!purchases.ContainsKey(marketProduct))
{
purchases.Add(marketProduct, amount);
}
else
{
purchases[marketProduct] += amount;
}
}
public void SetItemInfo(MarketProduct marketProduct, int market)
{
purchasePrice.text = marketProduct.basePurchasePrice + "$";
salePrice.text = marketProduct.baseSellingPrice + "$";
minimumPurchase.text = marketProduct.minimumPurchaseAmount.ToString();
minimumSale.text = marketProduct.minimumSaleAmount.ToString();
demand.text = (marketProduct.demand - GameManager.Market.GetSalesAmount(market, marketProduct)).ToString();
offer.text = (marketProduct.offer - GameManager.Market.GetPurchaseAmount(market, marketProduct)).ToString();
amountOnInventory.text = GameManager.Inventory.GetItemFinalProductAmount(marketProduct.product).ToString();
this.marketProduct = marketProduct;
this.marketIndex = market;
}
private void UpdateDemand(int marketIndex, MarketProduct marketProduct, int amount)
{
print("Called demand");
if (marketIndex == this.marketIndex &&
marketProduct == this.marketProduct)
{
print("pass demand");
var salesAmount = GameManager.Market.GetSalesAmount(marketIndex, marketProduct);
var demand = marketProduct.demand - salesAmount;
print("sales amount: " + salesAmount + " - demand: " + demand);
this.demand.text = demand.ToString();
}
}
private decimal CalcNewPrice(MarketProduct marketProduct, int addedAmount)
{
int newAmount = marketProduct.AmountAvailable + addedAmount;
if (newAmount == 0)
{
return(decimal.MaxValue);
}
if (newAmount > 100000000)
{
return(0.01m);
}
return(Convert.ToDecimal((1 / Math.Pow(newAmount, 1.01)) * 1000000));
}
public void products()
{
InfoFormPrice.CurrentProgressBar = 0;
InfoFormPrice.MaxProgressBar = Links.Count();
foreach (string link in Links)
{
browserFirst.Navigate().GoToUrl(link);
while (true)
{
IWebElement[] boxs = browserFirst.FindElementsByClassName("item-box").ToArray();
string category = browserFirst.FindElement(By.XPath("/html/body/div[6]/div[5]/div/div[1]/div/div[2]/ul/li[2]")).Text;
foreach (IWebElement box in boxs)
{
try
{
string name = "", url = "", image = "", barcode = "", price = "";
name = box.FindElement(By.TagName("h2")).Text;
image = box.FindElement(By.TagName("img")).GetAttribute("src");
int catId = categories.IndexOf(category.Trim()) + 1;
url = box.FindElement(By.TagName("a")).GetAttribute("href");
barcode = BrowserSecond(url);
price = box.FindElement(By.ClassName("actual-price")).Text;
InfoFormPrice.CurrentTitle = name + " -- " + barcode + " -- " + category;
Product product = addProduct(name, image, catId, barcode, true);
MarketProduct marketproduct = addMarketProduct(MarketId, product.Id, url);
ProductPrice productPrice = addPrice(product.Id, price, "TL", DateTime.Now);
}
catch (Exception ex)
{
continue;
}
}
if (browserFirst.FindElementsByClassName("next-page").Count != 0)
{
browserFirst.FindElementByClassName("next-page").Click();
}
else
{
break;
}
delay(2);
}
InfoFormPrice.CurrentProgressBar++;
}
}
public void InitializePurchasing()
{
if (IsInitialized())
{
return;
}
var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance());
// Store Product
//#if UNITY_ANDROID
// builder.AddProduct("Remove_Ads_1_99", ProductType.Subscription, new IDs(){
// { "remove_ads_1_99_android", GooglePlay.Name}
// });
//#elif UNITY_IOS
// builder.AddProduct("Remove_Ads_1_99", ProductType.NonConsumable, new IDs(){
// { "Remove_Ads_1_99", AppleAppStore.Name },
// });
//#endif
marketProductDictionary = new Dictionary <string, MarketProduct>();
marketProductEDictionary = new Dictionary <EMarketProduct, List <MarketProduct> >();
for (int i = 0; i < marketProductList.Count; i++)
{
MarketProduct marketProduct = marketProductList[i];
marketProductDictionary.Add(marketProduct.Id, marketProduct);
if (marketProductEDictionary.ContainsKey(marketProduct.EMarketProduct))
{
marketProductEDictionary[marketProduct.EMarketProduct].Add(marketProduct);
}
else
{
List <MarketProduct> list = new List <MarketProduct>();
list.Add(marketProduct);
marketProductEDictionary.Add(marketProduct.EMarketProduct, list);
}
builder.AddProduct(marketProduct.Id, marketProduct.Type, new IDs()
{
{ marketProduct.AppleAppStoreName, AppleAppStore.Name },
});
}
UnityPurchasing.Initialize(this, builder);
}
public void OnPost()
{
Int32.TryParse(AmountString, out int amount);
if (Bool2BuySell(BuySellBool) == BuySell.Sell)
{
amount *= -1;
}
Decimal.TryParse(ThresholdString.Replace(".", ","), out decimal threshold);
Trader trader = pandaRepo.GetTraderByName(UserHelpers.GetUsername(User));
MarketProduct marketProduct = pandaRepo.GetMarketProduct(ProductString);
pandaRepo.PlaceBookingOrder(new BookingOrder(trader, marketProduct, amount, threshold));
OnGet();
}
protected MarketProduct addMarketProduct(int MarketId, int ProductId, string URL)
{
MarketProduct marketProduct = new MarketProduct();
marketProduct.MarketId = MarketId;
marketProduct.ProductId = ProductId;
marketProduct.Url = URL;
MarketProduct returnMarketP = marketProductRepository.getMatch(MarketId, ProductId);
if (returnMarketP == null)
{
MarketProduct temp = marketProductRepository.Add(marketProduct);
return(temp);
}
return(returnMarketP);
}
private IEnumerator FakeProcessPurchase(MarketProduct marketProduct)
{
yield return(new WaitForSeconds(0.8f));
bool isPurchaseSuccessful = false;
foreach (var pair in marketProductDictionary)
{
if (String.Equals(marketProduct.Id, pair.Key, StringComparison.Ordinal))
{
Debug.Log(string.Format("FakeProcessPurchase: PASS. Product: '{0}'", marketProduct.Id));
isPurchaseSuccessful = true;
GameHelper.player.SetIsPaid(true);
if (marketProduct.Type == ProductType.NonConsumable)
{
GameHelper.Instance.purchaseMessage.ResetAllTransforms();
}
else
{
if (marketProduct.Id == "Craps_4_99_scratcher")
{
GameHelper.Instance.purchaseMessage.ShowScratcherPurchasedTransform();
}
else
{
GameHelper.Instance.coinCollectEffect.RunEffect(marketProduct.ChipAmount,
new Vector3(0.0f, 0.0f),
new Vector3(-95.0f, 100.0f),
new Vector3(-140.0f, 190));
GameHelper.Instance.purchaseMessage.ShowPurchasedTransform(marketProduct.ChipAmount);
}
}
break;
}
}
if (!isPurchaseSuccessful)
{
Debug.Log(string.Format("ProcessPurchase: FAIL. Unrecognized product: '{0}'", marketProduct.Id));
GameHelper.Instance.purchaseMessage.ShowPurchasedFailTransform();
}
}
public void Init(MarketProduct marketProduct)
{
this.marketProduct = marketProduct;
if (chipText != null)
{
chipText.text = GameHelper.CoinLongToString(marketProduct.ChipAmount);
}
if (originalChipText != null && marketProduct.OriginalChipAmount > 0)
{
originalChipText.text = GameHelper.CoinLongToString(marketProduct.OriginalChipAmount);
}
if (priceText != null)
{
priceText.text = marketProduct.Price.ToString();
}
}
private void DrawPrice(Purchase purchase, float productSize, float y)
{
if (purchase.IsMarketPurchase)
{
MarketProduct marketProduct = Market.Instance.ProductList[purchase.MarketID];
GUI.Label(new Rect(Screen.width / 2f, y + productSize * 2 / 3f, Screen.width, productSize / 3f), string.Format("{0}", marketProduct.FormattedPrice));
}
else
{
if (purchase.VirtualCurrency != null)
{
DrawVirtualCurrencyIcon(purchase.VirtualCurrency.ID, Screen.width / 2f - 25, y + productSize * 2 / 3f);
GUI.Label(new Rect(Screen.width / 2f, y + productSize * 2 / 3f, Screen.width, productSize / 3f), string.Format("{0}", purchase.Price));
}
else
{
GUI.Label(new Rect(Screen.width / 2f, y + productSize * 2 / 3f, Screen.width, productSize / 3f), "Null");
}
}
}
public MarketProduct CreateProduct(Product product, List <Class> classes, List <ProductStat> stats)
{
MarketProduct mProduct = new MarketProduct {
Discount = 0,
Quantity = 0,
Product = product
};
if (classes != null)
{
var ids = classes.Select(c => c.Id).ToArray();
mProduct.Product.Classes = _classRepository.Table.Where(x => ids.Any(c => c == x.Id)).ToList();
}
mProduct.Product.Stats = stats;
mProduct = _goodsRepository.Insert(mProduct);
return(mProduct);
}
public MarketProduct Add(MarketProduct marketProduct)
{
FoodEntities.MarketProducts.Add(marketProduct);
FoodEntities.SaveChanges();
return(marketProduct);
}
public void AddMarketProduct(MarketProduct marketProduct)
{
context.Market.Add(marketProduct);
context.Products.Add(marketProduct.Product);
context.SaveChanges();
}
public int GetPurchaseAmount(int marketIndex, MarketProduct marketProduct)
{
int id = FindMovementsIdByMarketIndex(marketIndex);
return(marketMovements[id].GetPurchasesAmount(marketProduct));
}
private void AddSale(int marketIndex, MarketProduct marketProduct, int amount)
{
int movementId = FindMovementsIdByMarketIndex(marketIndex);
marketMovements[movementId].AddSale(marketProduct, amount);
}
public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs args)
{
Debug.Log("transactionID : " + args.purchasedProduct.transactionID);
bool isPurchaseSuccessful = false;
bool isCheat = IsCheat(args.purchasedProduct.transactionID);
bool isSandBox = IsSandBox(args.purchasedProduct.transactionID);
if (isCheat)
{
Debug.Log(string.Format("ProcessPurchase: InValid. Unrecognized product: '{0}'", args.purchasedProduct.definition.id));
return(PurchaseProcessingResult.Complete);
}
foreach (var pair in marketProductDictionary)
{
if (String.Equals(args.purchasedProduct.definition.id, pair.Key, StringComparison.Ordinal))
{
MarketProduct marketProduct = pair.Value;
Debug.Log(string.Format("ProcessPurchase: PASS. Product: '{0}'", args.purchasedProduct.definition.id));
isPurchaseSuccessful = true;
GameHelper.player.SetIsPaid(true);
if (marketProduct.Type == ProductType.NonConsumable)
{
GameHelper.Instance.purchaseMessage.ResetAllTransforms();
}
else
{
if (args.purchasedProduct.definition.id == "Craps_4_99_scratcher")
{
GameHelper.Instance.purchaseMessage.ShowScratcherPurchasedTransform();
}
else
{
GameHelper.Instance.coinCollectEffect.RunEffect(marketProduct.ChipAmount,
new Vector3(0.0f, 0.0f),
new Vector3(-95.0f, 100.0f),
new Vector3(-140.0f, 190));
GameHelper.Instance.purchaseMessage.ShowPurchasedTransform(marketProduct.ChipAmount);
}
}
if (!isSandBox)
{
AppsFlyerManager.Instance.TrackIAP(marketProduct.Price.ToString(), "1");
}
break;
}
}
if (!isPurchaseSuccessful)
{
Debug.Log(string.Format("ProcessPurchase: FAIL. Unrecognized product: '{0}'", args.purchasedProduct.definition.id));
GameHelper.Instance.purchaseMessage.ShowPurchasedFailTransform();
}
return(PurchaseProcessingResult.Complete);
}
public MarketProduct getMatch(int marketId, int productId)
{
MarketProduct temp = FoodEntities.MarketProducts.SqlQuery("Select * from MarketProduct where ProductId=" + productId.ToString() + " and MarketId=" + marketId.ToString()).FirstOrDefault();
return(temp);
}
