protected void Page_PreRender(object sender, EventArgs e)
{
if (_customer.BonusCardNumber != null && (Card = BonusSystemService.GetCard(_customer.BonusCardNumber)) != null)
{
txtBonusFirstName.Text = Card.FirstName;
txtBonusLastName.Text = Card.LastName;
txtBonusSecondName.Text = Card.SecondName;
txtBonusDate.Text = Card.DateOfBirth != null
? ((DateTime)Card.DateOfBirth).ToString("dd.MM.yyyy")
: string.Empty;
txtBonusDate.Disabled = true;
txtBonusPhone.Text = Card.CellPhone;
genderMale.Checked = !Card.Gender;
genderFemale.Checked = Card.Gender;
btnMaAddBonusCard.Text = Resource.Client_Bonuses_SaveChanges;
btnMaAddBonusCard.CssClass = "ma-changecard";
}
else
{
txtBonusFirstName.Text = _customer.FirstName;
txtBonusLastName.Text = _customer.LastName;
txtBonusSecondName.Text = _customer.Patronymic;
btnMaAddBonusCard.Text = Resource.Client_Bonuses_AddCard;
btnMaAddBonusCard.CssClass = "ma-addcard";
txtBonusDate.CssClass += " mask-inp";
txtBonusPhone.CssClass += " mask-inp";
}
}
/// <summary>
/// Calculate bonus points based on cards built on current/left/right cities.
/// </summary>
/// <param name="bonusCard">The card giving the bonus.</param>
/// <param name="leftCity">The left player's city.</param>
/// <param name="rightCity">The right player's city.</param>
/// <returns>The amount of points earned.</returns>
public int CalculateCardBonus(BonusCard bonusCard, CityManager leftCity, CityManager rightCity)
{
List <Card> cardsToCheck = new List <Card>();
int bonusPoints = 0;
if (bonusCard.CheckSelf)
{
cardsToCheck.AddRange(this.GetAllBuildings(bonusCard.BonusCardType));
}
if (bonusCard.CheckLeft)
{
cardsToCheck.AddRange(leftCity.GetAllBuildings(bonusCard.BonusCardType));
}
if (bonusCard.CheckRight)
{
cardsToCheck.AddRange(rightCity.GetAllBuildings(bonusCard.BonusCardType));
}
foreach (Card c in cardsToCheck)
{
foreach (Card.CardType bonusType in bonusCard.BonusCardType)
{
bonusPoints += GetBonusPoints(bonusType, c, bonusCard);
}
}
return(bonusPoints);
}
public static BonusCard RandomBonusCard()
{
System.Random random = new System.Random();
BonusCard bc = (BonusCard)random.Next((int)BonusCard.AllSeven1);
return(bc);
}
private void btnAddClient_Click(object sender, RoutedEventArgs e)
{
this._card = new BonusCard();
_card.FirstName = this.txtFirstName.Text;
_card.LastName = this.txtLastName.Text;
_card.PhoneNumber = this.txtPhoneNumber.Text;
AddNewClient();
}
/**
* Overloaded method.
* Displays the data unique for BonusCard.
*/
public void DisplayCard(BonusCard card)
{
paymentLabel1.Text = "Payment per bonu cards owned:";
paymentLabel2.Text = "One card:" + card.GetPayment(1) + "m";
paymentLabel3.Text = "Two cards:" + card.GetPayment(2) + "m";
paymentLabel4.Text = "Three cards:" + card.GetPayment(3) + "m";
apartmentCostLabel.Text = "Four cards:" + card.GetPayment(4) + "m";
mortgageLabel.Text = "Mortgage: " + card.MortgageValue + "m";
DisplayCard(card, Color.Black, Color.White);
}
public BonusCard Clone()
{
BonusCard card = new BonusCard();
card.cardInfo = this.cardInfo;
card.manaCost = this.manaCost;
card.features = this.features;
return(card);
}
public async Task <FullInfoBonusCard> SearchBonusCard([FromBody] SearchBonusCardApiModel searchBonus)
{
// Make sure we have a number
if (searchBonus?.CardOrPhoneNumber == null || string.IsNullOrWhiteSpace(searchBonus.CardOrPhoneNumber))
{
return new FullInfoBonusCard()
{
ErrorMessage = "Invalid card or phone number"
}
}
;
// Is it phone number?
var isPhoneNumber = searchBonus.CardOrPhoneNumber.Length > 6 && searchBonus.CardOrPhoneNumber.Length <= 10;
var bonusCard = isPhoneNumber ?
Context.Clients.Include(p => p.BonusCard).FirstOrDefault(p => p.PhoneNumber.Equals(searchBonus.CardOrPhoneNumber)) :
Context.Clients.Include(p => p.BonusCard).FirstOrDefault(p => p.BonusCard.CardNumber.Equals(searchBonus.CardOrPhoneNumber));
// If we failed to find a card...
if (bonusCard == null)
{
return new FullInfoBonusCard()
{
ErrorMessage = "Card not found"
}
}
;
var newClient = new Client
{
ClientId = bonusCard.ClientId,
FirstName = bonusCard.FirstName,
LastName = bonusCard.LastName,
PhoneNumber = bonusCard.PhoneNumber
};
var newbonusCard = new BonusCard
{
ClientId = newClient.ClientId,
CardNumber = bonusCard.BonusCard.CardNumber,
Balance = bonusCard.BonusCard.Balance,
ExpirationDate = bonusCard.BonusCard.ExpirationDate
};
return(new FullInfoBonusCard()
{
FirstName = newClient.FirstName,
LastName = newClient.LastName,
PhoneNumber = newClient.PhoneNumber,
CardNumber = newbonusCard.CardNumber,
Balance = newbonusCard.Balance,
ExpirationDate = newbonusCard.ExpirationDate
});
}
void Start()
{
float margin = GD.ScreenTopLeft.x + GD.MarginBig + GD.CardHeight;
List <BonusCard> cards = GSP.GameState.AvailableBonusCards;
for (int i = 0; i < cards.Count; i++)
{
BonusCard bc = cards[i];
DrawCard(new Vector2(margin, ED.Player1Name.y), bc);
margin += GD.CardWidth + GD.MarginSmall;
}
}
private static void DrawPlayerBonuses(Player player, float axisY)
{
float margin = ED.CardsSpaceStart;
for (int i = 0; i < player.ReceivedBonuses.Count; i++)
{
BonusCard c = player.ReceivedBonuses[i];
Vector2 position = new Vector2(margin, axisY);
DrawCard(position, c);
margin += GD.CardWidth + GD.MarginSmall;
}
}
public NewCard(BonusCard card)
{
InitializeComponent();
this._card = card;
this.txtFirstName.Text = _card.FirstName;
this.txtLastName.Text = _card.LastName;
this.txtPhoneNumber.Text = _card.PhoneNumber;
this.txtBalance.Text = _card.Balance.ToString();
this.dpExpDate.SelectedDate = DateTime.UtcNow.AddDays(1095);
this.txtCreationDate.Text = _card.CreationDate.ToString();
}
private static void DrawCard(Vector2 position, BonusCard card)
{
Object obj = Resources.Load("Prefabs/Card");
GameObject prefab = Instantiate(obj) as GameObject;
GameObject canvas = GameObject.Find("Canvas");
prefab.transform.SetParent(canvas.transform);
Image image = prefab.GetComponent <Image>();
image.overrideSprite = CardsGenerator.GetSpriteForBonus(card);
prefab.transform.position = new Vector3(position.x, position.y, 0);
}
protected void Page_PreRender(object sender, EventArgs e)
{
if (PageData == null)
{
return;
}
if (!BonusSystem.IsActive)
{
this.Visible = false;
return;
}
var customer = CustomerContext.CurrentCustomer;
var cardNumber = customer.RegistredUser ? customer.BonusCardNumber : PageData.Customer.BonusCardNumber;
Card = BonusSystemService.GetCard(cardNumber);
if (Card != null)
{
liBonusAmount.Text = string.Format("({0} {1} {2})",
Resource.Client_StepBonus_YourBonuses,
Card.BonusAmount,
Strings.Numerals(Card.BonusAmount, Resource.Client_StepBonus_Empty,
Resource.Client_StepBonus_1Bonus,
Resource.Client_StepBonus_2Bonus,
Resource.Client_StepBonus_5Bonus));
chkBonus.Checked = PageData.UseBonuses;
}
if (customer.RegistredUser)
{
txtBonusLastName.Text = customer.LastName;
txtBonusFirstName.Text = customer.FirstName;
txtBonusSecondName.Text = customer.Patronymic;
if (customer.Phone.IsNotEmpty())
{
txtBonusPhone.Text = customer.Phone;
}
}
if (BonusSystem.BonusesForNewCard != 0)
{
liBonusesForNewCard.Text = string.Format(Resource.Client_StepBonus_NewCardBonuses,
CatalogService.GetStringPrice(BonusSystem.BonusesForNewCard));
liBonusesForNewCard.Visible = true;
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack && CustomerContext.CurrentCustomer.RegistredUser)
{
Response.Redirect("default.aspx");
}
SetRequiredFields();
if (!Page.IsPostBack && Demo.IsDemoEnabled)
{
txtEmail.Text = Demo.GetRandomEmail();
dvDemoDataUserNotification.Visible = true;
txtFirstName.Text = Demo.GetRandomName();
txtLastName.Text = Demo.GetRandomLastName();
txtPhone.Text = Demo.GetRandomPhone();
}
if (SettingsMain.EnablePhoneMask)
{
txtPhone.CssClass = "mask-phone mask-inp";
}
if (BonusSystem.IsActive)
{
var bonusCard = Session["bonuscard"] != null ? Session["bonuscard"].ToString() : null;
if (bonusCard.IsNotEmpty())
{
Card = BonusSystemService.GetCard(bonusCard.TryParseLong(true));
}
if (BonusSystem.BonusesForNewCard != 0)
{
liBonusesForNewCard.Text = string.Format(Resource.Client_StepBonus_NewCardBonuses,
CatalogService.GetStringPrice(BonusSystem.BonusesForNewCard));
liBonusesForNewCard.Visible = true;
}
}
NewsSubscription.Visible = SettingsDesign.NewsSubscriptionVisibility;
liCaptcha.Visible = SettingsMain.EnableCaptcha;
SetMeta(
new MetaInfo(string.Format("{0} - {1}", SettingsMain.ShopName, Resource.Client_Registration_Registration)),
string.Empty);
}
public Card(BonusCard card)
{
InitializeComponent();
this._card = card;
this.txtFirstName.Text = _card.FirstName;
this.txtLastName.Text = _card.LastName;
this.txtPhoneNumber.Text = _card.PhoneNumber;
this.txtBalance.Text = _card.Balance.ToString();
this.tbBonusValue.Text = 100.ToString();
this.txtCardNumber.Text = _card.CardNumber;
this.txtCreationDate.Text = _card.CreationDate.ToString();
//this.txtBonus = _card.Balance.ToString();
}
public async Task <IActionResult> Debit(BonusCardMoneyView model)
{
if (model is null)
{
return(NotFound());
}
try
{
BonusCard card = await _debit.DebitAsync(model);
return(RedirectToAction("View", new { controller = "Client", id = card.Client.Id }));
}
catch (CardNotFoundException)
{
return(NotFound());
}
}
/// <summary>
/// Get the list of values present on a given card.
/// </summary>
/// <param name="card">The card to analyze.</param>
/// <returns>The list of values present on the card.</returns>
private int[] GetSymbolsValue(Card card)
{
List <int> symbolsValue = new List <int>();
if (card.Type == Card.CardType.CIVIL)
{
symbolsValue.Add(((CivilCard)card).VictoryPoints);
}
else if (card.Type == Card.CardType.COMMERCIAL && card is BonusCard)
{
BonusCard bc = (BonusCard)card;
if (bc.Bonus == BonusCard.BonusType.FREE_BONUS)
{
symbolsValue.Add(bc.Reward[0].Quantity);
}
}
return(symbolsValue.ToArray());
}
public void TestEnumListEqual()
{
List <BonusCard> list1 = new List <BonusCard>();
List <BonusCard> list2 = new List <BonusCard>();
BonusCard b1 = RM.RandomBonusCard();
BonusCard b2 = RM.RandomBonusCard();
BonusCard b3 = RM.RandomBonusCard();
list1.Add(b1);
list1.Add(b2);
list1.Add(b3);
list2.Add(b1);
list2.Add(b2);
list2.Add(b3);
Assert.IsTrue(list1.IsEqualTo(list2));
}
/// <summary>
/// Get commercial instant bonus (if applicable).
/// </summary>
/// <param name="bc">The commercial bonus card granting the bonus.</param>
public void ApplyDirectCommercialBonus(BonusCard bc)
{
if (bc.BonusCardType.Length == 0)
{
if (bc.Bonus != BonusCard.BonusType.WONDER_BONUS)
{
this.Owner.Coins += bc.Reward[0].Quantity;
}
else
{
List <Player> players = GameManager.Instance().Players;
this.Owner.Coins += this.CalculateWonderBonus(players.ToArray(), players.IndexOf(this.Owner), true) * bc.Reward.Where(r => r.Reward == RewardType.GOLD).First().Quantity;
}
}
else
{
CityManager leftCity = GameManager.Instance().GetLeftCity(this.Owner);
CityManager rightCity = GameManager.Instance().GetRightCity(this.Owner);
this.Owner.Coins += this.CalculateCardBonus(bc, leftCity, rightCity);
}
}
//protected string RenderPrice(float productPrice, float discount)
//{
// if (productPrice == 0)
// {
// return string.Format("<div class=\'price\'>{0}</div>", Resource.Client_Catalog_ContactWithUs);
// }
// string res;
// float price = CatalogService.CalculateProductPrice(productPrice, 0, customerGroup, null);
// float priceWithDiscount = CatalogService.CalculateProductPrice(productPrice, discount, customerGroup, null);
// if (price.Equals(priceWithDiscount))
// {
// res = string.Format("<div class=\'price\'>{0}</div>", CatalogService.GetStringPrice(price));
// }
// else
// {
// res = string.Format("<div class=\"price-old\">{0}</div><div class=\"price\">{1}</div><div class=\"price-benefit\">{2} {3} {4} {5}% </div>",
// CatalogService.GetStringPrice(productPrice),
// CatalogService.GetStringPrice(priceWithDiscount),
// Resource.Client_Catalog_Discount_Benefit,
// CatalogService.GetStringPrice(price - priceWithDiscount),
// Resource.Client_Catalog_Discount_Or,
// CatalogService.FormatPriceInvariant(discount));
// }
// return res;
//}
private void LoadModules()
{
var discountModule = AttachedModules.GetModules <IDiscount>().FirstOrDefault();
if (discountModule != null)
{
var classInstance = (IDiscount)Activator.CreateInstance(discountModule);
_productDiscountModels = classInstance.GetProductDiscountsList();
}
_customLabels = new List <ProductLabel>();
foreach (var labelModule in AttachedModules.GetModules <ILabel>())
{
var classInstance = (ILabel)Activator.CreateInstance(labelModule);
var labelCode = classInstance.GetLabel();
if (labelCode != null)
{
_customLabels.Add(labelCode);
}
}
var bonusSystem = AttachedModules.GetModules <IBonusSystem>().FirstOrDefault();
if (bonusSystem != null)
{
if (CustomerContext.CurrentCustomer.BonusCardNumber != null)
{
_bonusCard = BonusSystemService.GetCard(CustomerContext.CurrentCustomer.BonusCardNumber);
}
else if (BonusSystem.BonusFirstPercent != 0)
{
_bonusCard = new BonusCard()
{
BonusPercent = BonusSystem.BonusFirstPercent
};
}
}
}
public static bool IsEqualTo(this List <BonusCard> l1, List <BonusCard> l2)
{
if (l1 == null || l2 == null)
{
throw new System.InvalidProgramException("Cannot compare nulls!");
}
if (l1.Count != l2.Count)
{
return(false);
}
for (int i = 0; i < l1.Count; i++)
{
BonusCard bc1 = l1[i];
BonusCard bc2 = l2[i];
if (bc1 != bc2)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Get amount of bonus points according to bonus card type.
/// </summary>
/// <param name="bonusCardType">The bonus card type.</param>
/// <param name="card">The current card being checked.</param>
/// <param name="bonusCard">The bonus card giving the current bonus.</param>
/// <returns>The amount of points earned.</returns>
private int GetBonusPoints(Card.CardType bonusCardType, Card card, BonusCard bonusCard)
{
int points = 0;
string[] manufacturedResourcesCardNames = new string[] { "Presse", "Metier a tisser", "Verrerie" };
if (bonusCardType == Card.CardType.RESOURCE && card.Type == Card.CardType.RESOURCE)
{
if (bonusCard.ResourceKind == BonusCard.ResourceMetaType.MANUFACTURED)
{
if (manufacturedResourcesCardNames.Contains(card.Name))
{
points += 2;
}
}
else if (bonusCard.ResourceKind == BonusCard.ResourceMetaType.RAW)
{
if (!manufacturedResourcesCardNames.Contains(card.Name))
{
points++;
}
}
else // "Guilde des armateurs"
{
points++;
}
}
else
{
if (bonusCardType == card.Type)
{
points++;
}
}
return(points);
}
private Order CreateOrder(ShoppingCart shoppingCart)
{
var orderConfirmData = PageData.OrderConfirmationData;
var customerGroup = CustomerContext.CurrentCustomer.CustomerGroup;
var baseCurrency = CurrencyService.BaseCurrency;
var ord = new Order
{
OrderCustomer = new OrderCustomer
{
CustomerIP = Request.UserHostAddress,
CustomerID = orderConfirmData.Customer.Id,
FirstName = orderConfirmData.Customer.FirstName,
LastName = orderConfirmData.Customer.LastName,
Patronymic = orderConfirmData.Customer.Patronymic,
Email = orderConfirmData.Customer.EMail,
MobilePhone = orderConfirmData.Customer.Phone,
},
OrderCurrency = new OrderCurrency
{
//CurrencyCode = CurrencyService.CurrentCurrency.Iso3,
//CurrencyValue = CurrencyService.CurrentCurrency.Value,
//CurrencySymbol = CurrencyService.CurrentCurrency.Symbol,
//CurrencyNumCode = CurrencyService.CurrentCurrency.NumIso3,
//IsCodeBefore = CurrencyService.CurrentCurrency.IsCodeBefore
CurrencyCode = baseCurrency.Iso3,
CurrencyValue = baseCurrency.Value,
CurrencySymbol = baseCurrency.Symbol,
CurrencyNumCode = baseCurrency.NumIso3,
IsCodeBefore = baseCurrency.IsCodeBefore
},
OrderStatusId = OrderService.DefaultOrderStatus,
AffiliateID = 0,
OrderDate = DateTime.Now,
CustomerComment = orderConfirmData.CustomerComment,
ShippingContact = new OrderContact
{
Name = orderConfirmData.ShippingContact.Name,
Country = orderConfirmData.ShippingContact.Country,
Zone = orderConfirmData.ShippingContact.RegionName,
City = orderConfirmData.ShippingContact.City,
Zip = orderConfirmData.ShippingContact.Zip,
Address = orderConfirmData.ShippingContact.Address,
CustomField1 = orderConfirmData.ShippingContact.CustomField1,
CustomField2 = orderConfirmData.ShippingContact.CustomField2,
CustomField3 = orderConfirmData.ShippingContact.CustomField3
},
GroupName = customerGroup.GroupName,
GroupDiscount = customerGroup.GroupDiscount,
OrderDiscount = shoppingCart.DiscountPercentOnTotalPrice
};
foreach (var orderItem in shoppingCart.Select(item => (OrderItem)item))
{
ord.OrderItems.Add(orderItem);
}
if (!orderConfirmData.BillingIsShipping)
{
ord.BillingContact = new OrderContact
{
Name = orderConfirmData.BillingContact.Name,
Country = orderConfirmData.BillingContact.Country,
Zone = orderConfirmData.BillingContact.RegionName,
City = orderConfirmData.BillingContact.City,
Zip = orderConfirmData.BillingContact.Zip,
Address = orderConfirmData.BillingContact.Address,
CustomField1 = orderConfirmData.BillingContact.CustomField1,
CustomField2 = orderConfirmData.BillingContact.CustomField2,
CustomField3 = orderConfirmData.BillingContact.CustomField3
};
}
ord.ShippingMethodId = orderConfirmData.SelectedShippingItem.MethodId;
ord.PaymentMethodId = orderConfirmData.SelectedPaymentItem.PaymenMethodtId;
ord.ArchivedShippingName = orderConfirmData.SelectedShippingItem.MethodNameRate;
ord.ArchivedPaymentName = orderConfirmData.SelectedPaymentItem.Name;
ord.PaymentDetails = orderConfirmData.PaymentDetails;
if (orderConfirmData.SelectedShippingItem.Ext != null &&
orderConfirmData.SelectedShippingItem.Ext.PickpointAddress.IsNotEmpty())
{
ord.OrderPickPoint = new OrderPickPoint
{
PickPointId = orderConfirmData.SelectedShippingItem.Ext.PickpointId,
PickPointAddress = orderConfirmData.SelectedShippingItem.Ext.PickpointAddress,
AdditionalData = orderConfirmData.SelectedShippingItem.Ext.AdditionalData
};
}
else if (orderConfirmData.SelectedShippingItem.Ext != null &&
orderConfirmData.SelectedShippingItem.Ext.Type == ExtendedType.Cdek &&
orderConfirmData.SelectedShippingItem.Ext.PickpointAddress.IsNullOrEmpty())
{
ord.OrderPickPoint = new OrderPickPoint
{
PickPointId = orderConfirmData.SelectedShippingItem.Ext.PickpointId,
PickPointAddress = ord.ShippingContact.Address,
AdditionalData = orderConfirmData.SelectedShippingItem.Ext.AdditionalData
};
}
else if (orderConfirmData.SelectedShippingItem.Type == ShippingType.CheckoutRu &&
orderConfirmData.SelectedShippingItem.Ext != null)
{
ord.OrderPickPoint = new OrderPickPoint
{
PickPointId = orderConfirmData.SelectedShippingItem.Ext.PickpointId,
PickPointAddress = orderConfirmData.SelectedShippingItem.Ext.Type != ExtendedType.CashOnDelivery
? ord.ShippingContact.Address
: string.Empty,
AdditionalData = orderConfirmData.SelectedShippingItem.Ext.AdditionalData
};
}
var certificate = shoppingCart.Certificate;
var coupon = shoppingCart.Coupon;
if (certificate != null)
{
ord.Certificate = new OrderCertificate()
{
Code = certificate.CertificateCode,
Price = certificate.Sum
};
}
if (coupon != null && shoppingCart.TotalPrice >= coupon.MinimalOrderPrice)
{
ord.Coupon = new OrderCoupon()
{
Code = coupon.Code,
Type = coupon.Type,
Value = coupon.Value
};
}
var shippingPrice = orderConfirmData.SelectedPaymentItem.Type == PaymentType.CashOnDelivery && (orderConfirmData.SelectedShippingItem.Type != ShippingType.Cdek || orderConfirmData.SelectedShippingItem.Type != ShippingType.CheckoutRu)
? orderConfirmData.SelectedShippingItem.Ext != null
? orderConfirmData.SelectedShippingItem.Ext.PriceCash
: 0
: orderConfirmData.SelectedShippingItem.Rate;
BonusCard bonusCard = null;
if (BonusSystem.IsActive)
{
bonusCard = BonusSystemService.GetCard(orderConfirmData.Customer.BonusCardNumber);
if (bonusCard != null && orderConfirmData.UseBonuses && bonusCard.BonusAmount > 0)
{
ord.BonusCost =
BonusSystemService.GetBonusCost(
shoppingCart.TotalPrice - shoppingCart.TotalDiscount + shippingPrice,
shoppingCart.TotalPrice - shoppingCart.TotalDiscount, bonusCard.BonusAmount);
}
}
var taxTotal =
AdvantShop.Taxes.TaxServices.CalculateTaxes(shoppingCart.TotalPrice - shoppingCart.TotalDiscount +
shippingPrice - ord.BonusCost).Where(tax => !tax.Key.ShowInPrice).Sum(tax => tax.Value);
var paymentPrice = orderConfirmData.SelectedPaymentItem.ExtrachargeType == ExtrachargeType.Percent
? (shoppingCart.TotalPrice - shoppingCart.TotalDiscount + shippingPrice - ord.BonusCost + taxTotal) * orderConfirmData.SelectedPaymentItem.Extracharge / 100
: orderConfirmData.SelectedPaymentItem.Extracharge;
ord.ShippingCost = shippingPrice;
ord.PaymentCost = paymentPrice;
ord.Number = OrderService.GenerateNumber(1); // For crash protection
ord.OrderID = OrderService.AddOrder(ord);
ord.Number = OrderService.GenerateNumber(ord.OrderID); // new number
OrderService.UpdateNumber(ord.OrderID, ord.Number);
ModulesRenderer.OrderAdded(ord.OrderID);
OrderService.ChangeOrderStatus(ord.OrderID, OrderService.DefaultOrderStatus);
if (BonusSystem.IsActive && bonusCard != null)
{
var sumPrice = BonusSystem.BonusType == BonusSystem.EBonusType.ByProductsCostWithShipping
? shoppingCart.TotalPrice - shoppingCart.TotalDiscount + shippingPrice
: shoppingCart.TotalPrice - shoppingCart.TotalDiscount;
BonusSystemService.MakeBonusPurchase(bonusCard.CardNumber, sumPrice, ord.BonusCost, ord.Number, ord.OrderID);
}
TrialService.TrackEvent(
ord.OrderItems.Any(item => item.Name.Contains("SM-G900F"))
? TrialEvents.BuyTheProduct
: TrialEvents.CheckoutOrder, string.Empty);
return(ord);
}
/// <summary>
/// Get the list of symbols names present on given card.
/// </summary>
/// <param name="card">The card to analyze.</param>
/// <returns>The list of symbols present on the card.</returns>
private string[] GetSymbolNames(Card card)
{
List <string> symbolNames = new List <string>();
switch (card.Type)
{
case Card.CardType.RESOURCE:
ResourceCard rc = ((ResourceCard)card);
foreach (Card.ResourceQuantity rq in rc.Resources)
{
for (int i = 0; i < rq.Quantity; i++)
{
symbolNames.Add(rq.Type.ToString());
}
}
break;
case Card.CardType.WAR:
for (int i = 0; i < ((WarCard)card).WarPoints; i++)
{
symbolNames.Add(card.Type.ToString());
}
break;
case Card.CardType.CIVIL:
symbolNames.Add(card.Type.ToString());
break;
case Card.CardType.COMMERCIAL:
switch (card)
{
case ResourceCard rec:
symbolNames.AddRange(rec.Resources.Select(c => c.Type.ToString()));
break;
case BonusCard boc:
if (boc.Bonus == BonusCard.BonusType.WONDER_BONUS)
{
symbolNames.Add("MEDIUM_WONDER_BONUS");
}
else
{
if (!(boc.CheckLeft && boc.CheckRight))
{
if (boc.BonusCardType.Length == 0)
{
symbolNames.Add("coin");
}
else if (boc.BonusCardType[0] == Card.CardType.COMMERCIAL)
{
symbolNames.Add("MEDIUM_COMMERCIAL_BONUS");
}
else if (boc.BonusCardType[0] == Card.CardType.RESOURCE)
{
if (boc.ResourceKind == BonusCard.ResourceMetaType.RAW)
{
symbolNames.Add("MEDIUM_RAW_BONUS");
}
else
{
symbolNames.Add("MEDIUM_MANUFACTURED_BONUS");
}
}
}
else
{
if (boc.ResourceKind == BonusCard.ResourceMetaType.RAW)
{
symbolNames.Add("BIG_RAW_BONUS_COINS");
}
else
{
symbolNames.Add("BIG_MANUFACTURED_BONUS_COINS");
}
}
}
break;
case CommercialCard cc:
string comSymbol = "";
if (CityManager.RAW_RESOURCES.Where(rr => rr == cc.Resources.First().Type).Count() > 0)
{
comSymbol += "BIG_RAW";
if (cc.LeftPlayer)
{
comSymbol += "_LEFT";
}
else
{
comSymbol += "_RIGHT";
}
}
else
{
comSymbol += "BIG_MANUFACTURED";
}
symbolNames.Add(comSymbol);
break;
}
break;
case Card.CardType.SCIENCE:
symbolNames.Add(((ScienceCard)card).ScienceCardType.ToString());
break;
case Card.CardType.GUILD:
BonusCard bc = (BonusCard)card;
switch (bc.Bonus)
{
case BonusCard.BonusType.CARD_BONUS:
if (bc.BonusCardType.Length > 1)
{
symbolNames.Add("BIG_GUI_3_CARDS");
}
else
if (bc.BonusCardType[0] == Card.CardType.RESOURCE)
{
if (bc.ResourceKind == BonusCard.ResourceMetaType.RAW)
{
symbolNames.Add("BIG_GUI_RAW");
}
else
{
symbolNames.Add("BIG_GUI_MANUFACTURED");
}
}
else
{
symbolNames.Add("BIG_GUI_" + bc.BonusCardType[0].ToString());
}
break;
case BonusCard.BonusType.DEFEAT_BONUS:
symbolNames.Add("BIG_GUI_DEFEAT");
break;
case BonusCard.BonusType.SCIENCE_BONUS:
foreach (Card.ScienceType science_symbol in System.Enum.GetValues(typeof(Card.ScienceType)))
{
symbolNames.Add(science_symbol.ToString());
}
break;
case BonusCard.BonusType.WONDER_BONUS:
symbolNames.Add("BIG_GUI_WONDER");
break;
}
break;
}
return(symbolNames.ToArray());
}
/**
* Performs the start-of-turn action according to where the currentPlayer
* is located and the type of field.
*/
private void Action(FieldType fieldType, int diceRoll)
{
switch (fieldType)
{
case FieldType.PROPERTY:
DefaultCardAction(
(PropertyCard)propertyManager
.CardAt(gameplan.PlayerPosition(currentPlayer)), -1);
return;
case FieldType.TREASURE:
TreasureCard treasureCard = treasureCardManager.GetTreasureCard();
window.DisplayTreasureCard(treasureCard);
currentPlayer.Money += treasureCard.MoneyChange;
GameState = GameStage.SPECIAL_CARD;
return;
case FieldType.RISK:
RiskCard riskCard = riskCardManager.GetRiskCard();
window.DisplayRiskCard(riskCard);
if (PlayRiskCard(riskCard))
{
GameState = GameStage.HOLIDAY;
return;
}
GameState = GameStage.SPECIAL_CARD;
return;
case FieldType.START:
currentPlayer.Money += START_BONUS;
NextPlayer();
return;
case FieldType.PRISON:
GameState = GameStage.NO_ACTION;
currentPlayer.Blocked += 3;
currentPlayer.Prison = true;
window.MovePlayer(playerTurnPointer, gameplan.GoToPrison(currentPlayer, playerTurnPointer));
window.ShowMessage("You are imprisoned for 3 turns!");
Thread.Sleep(2000);
NextPlayer();
return;
case FieldType.PARKING:
window.ShowMessage("You are parking for 1 turn");
currentPlayer.Blocked += 2;
GameState = GameStage.SPECIAL_FIELD;
return;
case FieldType.TAX:
window.ShowMessage("Each of us has to pay taxes!");
if (currentPlayer.Money < TAX_PRICE)
{
window.ShowNoMoneyPay();
GameState = GameStage.NO_FUNDS_PAY;
break;
}
currentPlayer.Money -= TAX_PRICE;
GameState = GameStage.SPECIAL_FIELD;
break;
case FieldType.AGENCY:
Player agencyOwner = GetOwner(currentPlayer);
AgencyCard agencyCard = (AgencyCard)propertyManager
.CardAt(gameplan.PlayerPosition(currentPlayer));
DefaultCardAction(agencyCard, diceRoll);
break;
case FieldType.TAX_FINE:
window.ShowMessage("You have to pay taxes!");
if (currentPlayer.Money < TAX_FINE_COST)
{
window.ShowNoMoneyPay();
GameState = GameStage.NO_FUNDS_PAY;
break;
}
currentPlayer.Money -= TAX_FINE_COST;
GameState = GameStage.SPECIAL_FIELD;
break;
case FieldType.BONUS_PROPERTY:
Player bonusOwner = GetOwner(currentPlayer);
BonusCard bonusCard = (BonusCard)propertyManager
.CardAt(gameplan.PlayerPosition(currentPlayer));
DefaultCardAction(bonusCard, 0);
break;
case FieldType.VISIT:
window.ShowMessage("You are on a holiday and skip your turn.");
GameState = GameStage.HOLIDAY;
return;
default:
break;
}
}
public static Sprite GetSpriteForBonus(BonusCard bonusCard)
{
var fileUri = "Cards/";
switch (bonusCard)
{
case BonusCard.FirstPlayer:
fileUri += "1player";
break;
case BonusCard.FirstPlayerReverse:
fileUri += "1playerQ";
break;
case BonusCard.Building:
fileUri += "bonusBuilding";
break;
case BonusCard.Castle:
fileUri += "bonusCastle";
break;
case BonusCard.Mine:
fileUri += "bonusMine";
break;
case BonusCard.Cloister:
fileUri += "bonusCloister";
break;
case BonusCard.Knowledge:
fileUri += "bonusKnowledge";
break;
case BonusCard.Ship:
fileUri += "bonusShip";
break;
case BonusCard.Pasture:
fileUri += "bonusPasture";
break;
case BonusCard.AllSeven4:
fileUri += "bonus4";
break;
case BonusCard.AllSeven3:
fileUri += "bonus3";
break;
case BonusCard.AllSeven2:
fileUri += "bonus2";
break;
case BonusCard.AllSeven1:
fileUri += "bonus1";
break;
}
return(Resources.Load <Sprite>(fileUri));
}
