Esempio n. 1
0
    public void SwitchActiveCurrency(CurrencyType newActiveCurrency)
    {
        ActiveCurrency = newActiveCurrency;
        SecurePlayerPrefs.SetInt(PlayerPrefConstants.SETTING_CURRENCY, (int)newActiveCurrency);

        OnCurrencyChanged?.Invoke();
    }
Esempio n. 2
0
        public Result <bool> Add(ICurrency currency, double amount)
        {
            var canAdd = CanAdd(currency, amount);

            if (canAdd.result == false)
            {
                return(canAdd);
            }

            double before = 0f;

            if (_currencies.ContainsKey(currency) == false)
            {
                _currencies[currency] = amount;
            }
            else
            {
                before = _currencies[currency];
                _currencies[currency] += amount;
            }

//            logger.LogVerbose($"Added {Math.Round(amount, currency.decimals)} {currency}");
            OnCurrencyChanged?.Invoke(this, new CurrencyChangedResult <double>(currency, before, GetAmount(currency)));
            return(new Result <bool>(true));
        }
Esempio n. 3
0
        public Result <bool> Remove(ICurrency currency, double amount)
        {
            var canRemove = CanRemove(currency, amount);

            if (canRemove.result == false)
            {
                return(canRemove);
            }

            if (amount <= 0d)
            {
                return(true);
            }

            var before = _currencies[currency];

            _currencies[currency] -= amount;
            if (_currencies[currency] <= 0f)
            {
                _currencies.Remove(currency);
            }

//            logger.LogVerbose($"Removed {Math.Round(amount, currency.decimals)} {currency}");
            OnCurrencyChanged?.Invoke(this, new CurrencyChangedResult <double>(currency, before, GetAmount(currency)));
            return(new Result <bool>(true));
        }
Esempio n. 4
0
        private void CurrencyChanged()
        {
            OnCurrencyChanged?.Invoke(this);
            SavedCurrency savedCurrency = new SavedCurrency(id, currentAmount);

            BinaryPrefs.SetClass(id.ToString(), savedCurrency);
        }
Esempio n. 5
0
        public void Clear()
        {
            if (isReadOnly)
            {
                return;
            }

            foreach (var currency in _currencies)
            {
                OnCurrencyChanged?.Invoke(this, new CurrencyChangedResult <double>(currency.Key, currency.Value, 0f));
            }

            _currencies.Clear();
        }
        public void AddCurrency(CurrencyType currencyType, int amount)
        {
            var currencyIndex = currencies.FindIndex(x => x.currencyType == currencyType);

            if (currencyIndex == -1)
            {
                return;
            }

            var currency           = currencies[currencyIndex];
            var prevCurrencyAmount = currency.currencyAmount;

            currency.currencyAmount   = currency.currencyAmount + amount < 0 ? 0 : currency.currencyAmount + amount;
            currencies[currencyIndex] = currency;
            OnCurrencyChanged?.Invoke(currencyType, prevCurrencyAmount, currency.currencyAmount);
        }
Esempio n. 7
0
 public static void InvokeCurrencyChanged(CurrencyModel currencyModel)
 {
     OnCurrencyChanged?.Invoke(currencyModel);
     OnSave?.Invoke();
 }
 public void SetCurrency(int value)
 {
     Coins = value >= 0 ? value : 0;
     OnCurrencyChanged?.Invoke(Coins);
 }
 private void OnCurrencyChangedInvoker(Currency _currency)
 {
     OnCurrencyChanged?.Invoke(_currency);
 }