/// <summary>
/// The algorithm goes from quarters to nickels. Tries to give as many quarters,dimes, nickels(in this order) as possible
/// </summary>
/// <param name="RemainingAmount">The remaining amount to be tendered to the user</param>
/// <returns></returns>
public static decimal TenderChange(decimal TotalAmount, string ProductName)
{
decimal RemainingAmount = TotalAmount - ProductDictionary[ProductName].ProductPrice;
foreach (Coin coin in AcceptedCoinsDictionary.Keys)
{
CoinValues CoinValues = AcceptedCoinsDictionary[coin];
//Number of coins for the current coin value
int n = (int)(RemainingAmount / CoinValues.Value);
int i = 0;
//n > 0 only if the remaining Amount is greater than coin value
if (n > 0)
{
//Eg: This check ensures that the maximum number of coins <=n are subtracted without the coin count running negative.
while (CoinValues.Count > 0 && i < n)
{
i++;
CoinValues.Count--;
RemainingAmount = RemainingAmount - CoinValues.Value; //Subtract the amount taken off
}
}
if (RemainingAmount == 0)
{
return(0); //Indicates that the amount to be tendered has been fulfilled.
}
}
return(RemainingAmount); //Vending machine unable to tender this change
}
public ActionResult RefreshCurrency(string currencyname)
{
var coins = CoinValues.GetValues().ToList();
Coin coin = coins
.Where(v => v.Name.Contains(currencyname))
.First();
Coin Bitcoin = coins
.Where(v => v.Name == "Bitcoin".Replace(" ", string.Empty))
.First();
decimal CurrencyUsdPrice = coin.Price;
decimal BitcoinPrice = Bitcoin.Price;
var db = new SiteDbContext();
var user = db.Users.Find(User.Identity.GetUserId());
var UserUsdBalance = user.Balance * BitcoinPrice;
var UserCurrencyBalance = user.Wallet[currencyname.Replace(" ", string.Empty)];
var Data = Newtonsoft.Json.JsonConvert.SerializeObject(new
{
CurrencyUsdPrice = CurrencyUsdPrice,
BitcoinPrice = BitcoinPrice,
UserBtcBalance = user.Balance,
UserUsdBalance = UserUsdBalance,
UserCurrencyBalance = UserCurrencyBalance,
UserOrders = user.LimitOrders.ToList()
}, new JsonSerializerSettings
{
PreserveReferencesHandling = PreserveReferencesHandling.Objects
});
return(Json(Data, JsonRequestBehavior.AllowGet));
}
public ActionResult Index()
{
if (!Request.IsAuthenticated)
{
HomeAuthenticated model = new HomeAuthenticated();
var btc = CoinValues.GetStatistic().Where(c => c.Name.Contains("Bitcoin")).First();
model.Bitcoin = btc;
return(View(model));
}
else
{
SiteDbContext db = new SiteDbContext();
var user = db.Users.Find(User.Identity.GetUserId());
user.Transactions = user.Transactions;
user.Wallet = user.Wallet;
HomeAuthenticated model = new HomeAuthenticated();
model.UserData = db.Users.Find(User.Identity.GetUserId());
model.Bitcoin = CoinValues.GetStatistic().Where(c => c.Name.Contains("Bitcoin")).First();
var TotalBalanceUSD = ProfileController.CalculateTotalBalance(user);
model.TotalBalance = TotalBalanceUSD;
return(View(model));
}
}
private void Start()
{
_rotateCoin = new Routine <int, bool>(RotateCoin, this);
Coins.Assign(onInteract: i => _rotateCoin.Start(i, true, allowSimultaneousRuns: false));
coinStates = Helper.RandomBooleans(CoinCount);
hammingCodes = Get <KMBombInfo>().GetSerialNumber()
.Select(c => Chars.Contains(c))
.ToArray();
// This flips each coin if needed.
for (int i = 0; i < CoinCount; i++)
{
ApplyRotation(i, 0, 0.6f);
}
Log("The hamming code is {0}.",
hammingCodes.Select(b => b ? "1" : "0").Join(""));
Log("The coins are arranged as {0}, making the answer {1}. (chess-coordinates)",
CoinValues.Select(n => n % 2 == 1 ? "1" : "0").Join(""),
ToCoordinate(GetExampleAnswer()));
}
public ActionResult Statistics(string currency)
{
var Currencies = CoinValues.GetStatistic().Where(cur => cur.Name == currency);
var BitcoinPrice = CoinValues.GetValues().Where(c => c.Name == "Bitcoin").First().Price;
if (currency == null || Currencies.Count() == 0 || Currencies.Count() > 1)
{
return(View("Index"));
}
Coin Currency = Currencies.First();
var db = new SiteDbContext();
List <LimitOrder> Orders = db.LimitOrders.Where(c => c.Currency == Currency.Name).ToList();
List <Transaction> Transactions = db.Transactions.Where(c => c.Currency == Currency.Name).ToList();
Statistics statistics = new Statistics();
statistics.Volume = Transactions.Sum(tr => tr.TotalUSD);
statistics.TotalTransactions = Transactions.Count;
statistics.Currency = Currency;
statistics.OpenOrders = Orders.Count;
statistics.Orders = Orders;
statistics.Transactions = Transactions.OrderByDescending(tr => tr.Date).ToList();
statistics.BitcoinPrice = BitcoinPrice;
return(View(statistics));
}
public ActionResult Sell(string amount, string name)
{
decimal d;
if (!decimal.TryParse(amount, out d))
{
return(View("Index"));
}
var userId = User.Identity.GetUserId();
decimal sold = decimal.Parse(amount, CultureInfo.InvariantCulture);
decimal currencyPrice = CoinValues.GetValues().Where(v => v.Name == name).First().Price;
decimal bitcoin = CoinValues.GetBtcValue().Price;
decimal boughtPrice = sold * currencyPrice;
decimal btcPrice = boughtPrice / bitcoin;
using (var db = new SiteDbContext())
{
var user = db.Users.Find(userId);
var userBTC = user.Balance;
if (sold > user.Wallet[name.Replace(" ", string.Empty)] || sold < 0)
{
return(View("Index"));
}
user.Wallet[name.Replace(" ", string.Empty)] -= sold;
user.Balance += btcPrice;
//add Transaction
var transaction = new Transaction()
{
Amount = sold,
Currency = name,
Date = DateTime.Now,
User = user,
Type = "Sold",
CurrencyPrice = currencyPrice,
TotalUSD = sold * currencyPrice
};
db.Transactions.Add(transaction);
db.SaveChanges();
var Data = Newtonsoft.Json.JsonConvert.SerializeObject(new
{
CurrencyCurrentPrice = currencyPrice,
CurrencyBalance = user.Wallet[name.Replace(" ", string.Empty)],
UserBtcBalance = user.Balance,
UserUsdBalance = user.Balance * CoinValues.GetBtcValue().Price
});
ViewBag.Result = "Successfully";
return(Json(Data, JsonRequestBehavior.AllowGet));
}
}
public ActionResult Index(string currency)
{
if (currency == null)
{
// var Coins = CoinValues.GetValues().Skip(1).Take(49).ToList();
// for (int i = 2; i < 51; i++)
// {
// var image = Coins[i-2].CoinImage;
// // var number = i + 1;
// using (WebClient client = new WebClient())
// {
// client.DownloadFile(new Uri(image), Server.MapPath(Path.Combine("~/Resources/CoinImages/", +i + ".png")));
// }
// }
return(View());
}
var CurrencyName = CoinValues.GetCurrencyName().Where(c => c.Value == currency).First().Value;
var tradeData = new TradePage();
tradeData.Name = CurrencyName;
tradeData.Price = CoinValues.GetValues().Where(c => c.Name == CurrencyName).First().Price;
tradeData.PriceBTC = (tradeData.Price / CoinValues.GetBtcValue().Price);
tradeData.PriceBtcString = string.Format("{0:F8}", tradeData.PriceBTC).Replace(",", ".");
tradeData.ImageNumber = CoinValues.GetCurrencyName().Where(c => c.Value == currency).First().Key;
tradeData.AllCoins = CoinValues.GetCurrencyName();
using (var db = new SiteDbContext())
{
var user = db.Users.Find(User.Identity.GetUserId());
tradeData.UserBalanceBTC = user.Balance;
tradeData.UserBalanceUSD = user.Balance * CoinValues.GetBtcValue().Price;
user.Wallet = user.Wallet;
user.LimitOrders = user.LimitOrders.OrderByDescending(order => order.OrderDate).ToList();
tradeData.User = user;
tradeData.CurrencyBalance = user.Wallet[currency.Replace(" ", string.Empty)];
}
return(View("TradePage", tradeData));
}
public ActionResult BuyLimitOrder(string currencyname, string buyamount, string buyatprice)
{
var userId = User.Identity.GetUserId();
var db = new SiteDbContext();
var user = db.Users.Find(userId);
decimal BuyAmount = decimal.Parse(buyamount, CultureInfo.InvariantCulture);
decimal BuyAtPrice = decimal.Parse(buyatprice, CultureInfo.InvariantCulture);
if (BuyAmount == 0 || BuyAtPrice == 0 || BuyAtPrice < 0 || BuyAmount < 0)
{
return(View("Index"));
}
var TotalOrderBtcCost = BuyAmount * BuyAtPrice;
var Coins = CoinValues.GetValues().ToList();
if (Coins.Where(c => c.Name.Contains(currencyname)).Count() == 0)
{
return(View("TradePage"));
}
if (TotalOrderBtcCost > user.Balance)
{
return(View("TradePage"));
}
LimitOrder order = new LimitOrder()
{
User = user,
Amount = BuyAmount,
Currency = currencyname,
AtPrice = BuyAtPrice,
OrderType = "Buy",
OrderDate = DateTime.Now
};
db.LimitOrders.Add(order);
user.Balance -= TotalOrderBtcCost;
db.SaveChanges();
var Data = Newtonsoft.Json.JsonConvert.SerializeObject(new
{
UserBtc = user.Balance,
UserUsd = user.Balance * CoinValues.GetBtcValue().Price
});
return(Json(Data, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Adds coins of the specified denomination to the pocket.
/// </summary>
/// <param name="coinType">Coin denomination.</param>
/// <param name="numCoins">Number of coins to add.</param>
/// <param name="fast">Set to true when cloning for fast copy operation.</param>
internal void SetCoins(CoinValues coinType, int numCoins, bool fast = false)
{
purse[coinType] = numCoins;
if (!fast)
{
//Cleanup the purse of all smaller denomination for correct behavior.
List <CoinValues> valuesToRemove = new List <CoinValues>();
foreach (var pair in purse)
{
if (pair.Key < coinType)
{
valuesToRemove.Add(pair.Key);
}
}
valuesToRemove.ForEach(value => purse.Remove(value));
}
}
public ActionResult SellLimitOrder(string currencyname, string sellamount, string sellatprice)
{
var userId = User.Identity.GetUserId();
var db = new SiteDbContext();
var user = db.Users.Find(userId);
decimal SellAmount = decimal.Parse(sellamount, CultureInfo.InvariantCulture);
decimal BuyAtPrice = decimal.Parse(sellatprice, CultureInfo.InvariantCulture);
var TotalOrderBtcCost = SellAmount * BuyAtPrice;
var Coins = CoinValues.GetValues().ToList();
if (Coins.Where(c => c.Name.Contains(currencyname)).Count() == 0)
{
return(View("TradePage"));
}
if (user.Wallet[currencyname.Replace(" ", string.Empty)] < SellAmount)
{
return(View("TradePage"));
}
LimitOrder order = new LimitOrder()
{
User = user,
Amount = SellAmount,
Currency = currencyname,
OrderType = "Sell",
AtPrice = BuyAtPrice,
OrderDate = DateTime.Now
};
db.LimitOrders.Add(order);
user.Wallet[currencyname.Replace(" ", string.Empty)] -= SellAmount;
db.SaveChanges();
var Data = Newtonsoft.Json.JsonConvert.SerializeObject(new
{
UserCurrency = user.Wallet[currencyname.Replace(" ", string.Empty)]
});
return(Json(Data, JsonRequestBehavior.AllowGet));
}
private void btnAddCoin2_Click(object sender, RoutedEventArgs e)
{
TVMUtility.PlayClick();
if (!coin2)
{
return;
}
if (lblTypeCoin2.Text != "0")
{
if (CCTalkManager.Instance.coinHopperEV4000_2.Category != null)
{
CCTalkManager.Instance.coinHopperEV4000_2.GetHighLowStatus();
if (level == "Low Level")
{
if (Constants.CoinAvailable.Contains(lblTypeCoin1.Text))
{
CoinValues.setCoin2(lblTypeCoin2.Text);
Constants.HopperAddress2Coin = Convert.ToInt16(lblTypeCoin2.Text);
MessageBoxOperations.ShowMessage("COIN", "Coin hopper 2 value saved.", MessageBoxButtonSet.OK);
}
else
{
MessageBoxOperations.ShowMessage("COIN", "Entered coin value is wrong.", MessageBoxButtonSet.OK);
}
}
else
{
MessageBoxOperations.ShowMessage("COIN", "Please empty the hopper 2.", MessageBoxButtonSet.OK);
}
}
}
else
{
MessageBoxOperations.ShowMessage("COIN", "Please enter the coin value.", MessageBoxButtonSet.OK);
lblTypeCoin2.Focus();
}
coin2 = false;
}
public ActionResult Validate(string currencyname)
{
var db = new SiteDbContext();
var user = db.Users.Find(User.Identity.GetUserId());
var UserBtcBalance = user.Balance;
var UserCurrencyBalance = user.Wallet[currencyname.Replace(" ", string.Empty)];
var CurrencyPrice = CoinValues.GetValues().Where(v => v.Name.Contains(currencyname)).First();
var BitcoinPrice = CoinValues.GetBtcValue().Price;
var Data = Newtonsoft.Json.JsonConvert.SerializeObject(new
{
UserBtcBalance = UserBtcBalance,
UserCurrencyBalance = UserCurrencyBalance,
CurrencyPrice = CurrencyPrice.Price,
BitcoinPrice = BitcoinPrice
});
return(Json(Data, JsonRequestBehavior.AllowGet));
}
private void TaskLoop()
{
while (m_running)
{
var Coins = CoinValues.GetValues();
var Bitcoin = Coins.Where(name => name.Name.Contains("Bitcoin")).First();
var db = new SiteDbContext();
foreach (var coin in Coins)
{
CurrenciesChart chart = new CurrenciesChart()
{
CurrencyName = coin.Name,
Date = DateTime.Now,
CurrencyUsdValue = coin.Price,
CurrencyBtcValue = coin.Price / Bitcoin.Price
};
db.CurrenciesCharts.Add(chart);
}
db.SaveChanges();
Thread.Sleep(m_interval);
}
}
private void TaskLoop()
{
while (m_running)
{
try
{
var db = new SiteDbContext();
if (db.LimitOrders.Count() == 0)
{
return;
}
var Coins = CoinValues.GetValues();
var Orders = db.LimitOrders.OrderByDescending(order => order.OrderDate).ToList();
foreach (var order in Orders.ToList())
{
Coin coin = Coins.Where(c => c.Name.Contains(order.Currency)).First();
Coin Bitcoin = Coins.Where(c => c.Name.Contains("Bitcoin")).First();
decimal CoinBtcPrice = decimal.Round((coin.Price / Bitcoin.Price), 8);
if (CoinBtcPrice == decimal.Round(order.AtPrice, 8))
{
//Do ORDER
var User = db.Users.Find(order.User.Id);
if (order.OrderType == "Buy")
{
User.Wallet[order.Currency.Replace(" ", string.Empty)] += order.Amount;
db.LimitOrders.Remove(order);
Orders.Remove(order);
Transaction transaction = new Transaction()
{
Type = "Bought",
Currency = coin.Name,
Amount = order.Amount,
CurrencyPrice = coin.Price,
TotalUSD = order.Amount * coin.Price,
Date = DateTime.Now,
User = User
};
db.Transactions.Add(transaction);
db.SaveChanges();
}
;
if (order.OrderType == "Sell")
{
User.Balance += (CoinBtcPrice * order.Amount);
db.LimitOrders.Remove(order);
Orders.Remove(order);
Transaction transaction = new Transaction()
{
Type = "Sold",
Currency = coin.Name,
Amount = order.Amount,
CurrencyPrice = coin.Price,
TotalUSD = order.Amount * coin.Price,
Date = DateTime.Now,
User = User
};
db.Transactions.Add(transaction);
db.SaveChanges();
}
;
}
}
}
catch (Exception e)
{
}
Thread.Sleep(m_interval);
}
}
public ActionResult Analytics()
{
var getstatistic = CoinValues.GetStatistic();
return(View(getstatistic));
}
public ActionResult Buy(string amount, string name)
{
decimal d;
if (!decimal.TryParse(amount, out d))
{
return(View("Index"));
}
var userId = User.Identity.GetUserId();
decimal bought = decimal.Parse(amount, CultureInfo.InvariantCulture);
decimal currencyPrice = CoinValues.GetValues().Where(v => v.Name == name).First().Price;
decimal bitcoin = CoinValues.GetBtcValue().Price;
decimal boughtPrice = bought * currencyPrice;
decimal btcPrice = boughtPrice / bitcoin;
using (var db = new SiteDbContext())
{
var user = db.Users.Find(userId);
var userBTC = user.Balance;
if (userBTC < btcPrice || btcPrice < 0)
{
return(View("Index"));
}
user.Wallet[name.Replace(" ", string.Empty)] += bought;
user.Balance -= btcPrice;
//add Transaction
var transaction = new Transaction()
{
Amount = bought,
Currency = name,
Date = DateTime.Now,
User = user,
Type = "Bought",
CurrencyPrice = currencyPrice,
TotalUSD = bought * currencyPrice
};
db.Transactions.Add(transaction);
db.SaveChanges();
//Request.UrlReferrer.PathAndQuery
//string Data = "{\"name\":\"Joe\"}";
var Data = Newtonsoft.Json.JsonConvert.SerializeObject(new
{
CurrencyCurrentPrice = currencyPrice,
CurrencyBalance = user.Wallet[name.Replace(" ", string.Empty)],
UserBtcBalance = user.Balance,
UserUsdBalance = user.Balance * CoinValues.GetBtcValue().Price
});
return(Json(Data, JsonRequestBehavior.AllowGet));
}
}
public static decimal CalculateTotalBalance(ApplicationUser User)
{
List <Coin> Coins = CoinValues.GetValues();
List <LimitOrder> UserOrders = User.LimitOrders.ToList();
Dictionary <int, string> CurrencyNames = CoinValues.GetCurrencyName();
decimal TotalBalanceUSD = 0.00m;
var Bitcoin = Coins.Where(c => c.Name.Contains("Bitcoin")).First().Price;
TotalBalanceUSD += Bitcoin * User.Balance;
TotalBalanceUSD += UserOrders.Sum(ord => (ord.AtPrice * Bitcoin) * ord.Amount);
var Ethereum = Coins.Where(c => c.Name.Contains(CurrencyNames[2])).First().Price;
TotalBalanceUSD += Ethereum * User.Wallet.Ethereum;
var XRP = Coins.Where(c => c.Name.Contains(CurrencyNames[3])).First().Price;
TotalBalanceUSD += XRP * User.Wallet.XRP;
var EOS = Coins.Where(c => c.Name.Contains(CurrencyNames[4])).First().Price;
TotalBalanceUSD += EOS * User.Wallet.EOS;
var Litecoin = Coins.Where(c => c.Name.Contains(CurrencyNames[5])).First().Price;
TotalBalanceUSD += Litecoin * User.Wallet.Litecoin;
var BitcoinCash = Coins.Where(c => c.Name.Contains(CurrencyNames[6])).First().Price;
TotalBalanceUSD += BitcoinCash * User.Wallet.BitcoinCash;
var BinanceCoin = Coins.Where(c => c.Name.Contains(CurrencyNames[7])).First().Price;
TotalBalanceUSD += BinanceCoin * User.Wallet.BinanceCoin;
var Stellar = Coins.Where(c => c.Name.Contains(CurrencyNames[8])).First().Price;
TotalBalanceUSD += Stellar * User.Wallet.Stellar;
var Tether = Coins.Where(c => c.Name.Contains(CurrencyNames[9])).First().Price;
TotalBalanceUSD += Tether * User.Wallet.Tether;
var Cardano = Coins.Where(c => c.Name.Contains(CurrencyNames[10])).First().Price;
TotalBalanceUSD += Cardano * User.Wallet.Cardano;
var TRON = Coins.Where(c => c.Name.Contains(CurrencyNames[11])).First().Price;
TotalBalanceUSD += TRON * User.Wallet.TRON;
var BitcoinSV = Coins.Where(c => c.Name.Contains(CurrencyNames[12])).First().Price;
TotalBalanceUSD += BitcoinSV * User.Wallet.BitcoinSV;
var Dash = Coins.Where(c => c.Name.Contains(CurrencyNames[13])).First().Price;
TotalBalanceUSD += Dash * User.Wallet.Dash;
var Monero = Coins.Where(c => c.Name.Contains(CurrencyNames[14])).First().Price;
TotalBalanceUSD += Monero * User.Wallet.Monero;
var IOTA = Coins.Where(c => c.Name.Contains(CurrencyNames[15])).First().Price;
TotalBalanceUSD += IOTA * User.Wallet.IOTA;
var Maker = Coins.Where(c => c.Name.Contains(CurrencyNames[16])).First().Price;
TotalBalanceUSD += Maker * User.Wallet.Maker;
var Tezos = Coins.Where(c => c.Name.Contains(CurrencyNames[17])).First().Price;
TotalBalanceUSD += Tezos * User.Wallet.Tezos;
var Ontology = Coins.Where(c => c.Name.Contains(CurrencyNames[18])).First().Price;
TotalBalanceUSD += Ontology * User.Wallet.Ontology;
var NEO = Coins.Where(c => c.Name.Contains(CurrencyNames[19])).First().Price;
TotalBalanceUSD += NEO * User.Wallet.NEO;
var EthereumClassic = Coins.Where(c => c.Name.Contains(CurrencyNames[20])).First().Price;
TotalBalanceUSD += EthereumClassic * User.Wallet.EthereumClassic;
var NEM = Coins.Where(c => c.Name.Contains(CurrencyNames[21])).First().Price;
TotalBalanceUSD += NEM * User.Wallet.NEM;
var Zcash = Coins.Where(c => c.Name.Contains(CurrencyNames[22])).First().Price;
TotalBalanceUSD += Zcash * User.Wallet.Zcash;
var HuobiToken = Coins.Where(c => c.Name.Contains(CurrencyNames[23])).First().Price;
TotalBalanceUSD += HuobiToken * User.Wallet.HuobiToken;
var VeChain = Coins.Where(c => c.Name.Contains(CurrencyNames[24])).First().Price;
TotalBalanceUSD += VeChain * User.Wallet.VeChain;
var Waves = Coins.Where(c => c.Name.Contains(CurrencyNames[25])).First().Price;
TotalBalanceUSD += Waves * User.Wallet.Waves;
var Qtum = Coins.Where(c => c.Name.Contains(CurrencyNames[26])).First().Price;
TotalBalanceUSD += Qtum * User.Wallet.Qtum;
var OmiseGO = Coins.Where(c => c.Name.Contains(CurrencyNames[27])).First().Price;
TotalBalanceUSD += OmiseGO * User.Wallet.OmiseGO;
var Dogecoin = Coins.Where(c => c.Name.Contains(CurrencyNames[28])).First().Price;
TotalBalanceUSD += Dogecoin * User.Wallet.Dogecoin;
var USDCoin = Coins.Where(c => c.Name.Contains(CurrencyNames[29])).First().Price;
TotalBalanceUSD += USDCoin * User.Wallet.USDCoin;
var BitcoinGold = Coins.Where(c => c.Name.Contains(CurrencyNames[30])).First().Price;
TotalBalanceUSD += BitcoinGold * User.Wallet.BitcoinGold;
var MaximineCoin = Coins.Where(c => c.Name.Contains(CurrencyNames[31])).First().Price;
TotalBalanceUSD += MaximineCoin * User.Wallet.MaximineCoin;
var Lisk = Coins.Where(c => c.Name.Contains(CurrencyNames[32])).First().Price;
TotalBalanceUSD += Lisk * User.Wallet.Lisk;
var TrueUSD = Coins.Where(c => c.Name.Contains(CurrencyNames[33])).First().Price;
TotalBalanceUSD += TrueUSD * User.Wallet.TrueUSD;
var BitTorrent = Coins.Where(c => c.Name.Contains(CurrencyNames[34])).First().Price;
TotalBalanceUSD += BitTorrent * User.Wallet.BitTorrent;
var Ravencoin = Coins.Where(c => c.Name.Contains(CurrencyNames[35])).First().Price;
TotalBalanceUSD += Ravencoin * User.Wallet.Ravencoin;
var IOST = Coins.Where(c => c.Name.Contains(CurrencyNames[36])).First().Price;
TotalBalanceUSD += IOST * User.Wallet.IOST;
var Decred = Coins.Where(c => c.Name.Contains(CurrencyNames[37])).First().Price;
TotalBalanceUSD += Decred * User.Wallet.Decred;
var Chainlink = Coins.Where(c => c.Name.Contains(CurrencyNames[38])).First().Price;
TotalBalanceUSD += Chainlink * User.Wallet.Chainlink;
var Zilliqa = Coins.Where(c => c.Name.Contains(CurrencyNames[39])).First().Price;
TotalBalanceUSD += Zilliqa * User.Wallet.Zilliqa;
var Augur = Coins.Where(c => c.Name.Contains(CurrencyNames[40])).First().Price;
TotalBalanceUSD += Augur * User.Wallet.Augur;
var ICON = Coins.Where(c => c.Name.Contains(CurrencyNames[41])).First().Price;
TotalBalanceUSD += ICON * User.Wallet.ICON;
var BitShares = Coins.Where(c => c.Name.Contains(CurrencyNames[42])).First().Price;
TotalBalanceUSD += BitShares * User.Wallet.BitShares;
var Holo = Coins.Where(c => c.Name.Contains(CurrencyNames[43])).First().Price;
TotalBalanceUSD += Holo * User.Wallet.Holo;
var Verge = Coins.Where(c => c.Name.Contains(CurrencyNames[44])).First().Price;
TotalBalanceUSD += Verge * User.Wallet.Verge;
var DigiByte = Coins.Where(c => c.Name.Contains(CurrencyNames[45])).First().Price;
TotalBalanceUSD += DigiByte * User.Wallet.DigiByte;
var Nano = Coins.Where(c => c.Name.Contains(CurrencyNames[46])).First().Price;
TotalBalanceUSD += Nano * User.Wallet.Nano;
var Steem = Coins.Where(c => c.Name.Contains(CurrencyNames[47])).First().Price;
TotalBalanceUSD += Steem * User.Wallet.Steem;
var Bytecoin = Coins.Where(c => c.Name.Contains(CurrencyNames[48])).First().Price;
TotalBalanceUSD += Bytecoin * User.Wallet.Bytecoin;
var BitcoinDiamond = Coins.Where(c => c.Name.Contains(CurrencyNames[49])).First().Price;
TotalBalanceUSD += BitcoinDiamond * User.Wallet.BitcoinDiamond;
var Aeternity = Coins.Where(c => c.Name.Contains(CurrencyNames[50])).First().Price;
TotalBalanceUSD += Aeternity * User.Wallet.Aeternity;
return(TotalBalanceUSD);
}
public ApplicationUser()
{
this.Balance = 5000 / CoinValues.GetBtcValue().Price;
this.ProfilePicture = "/Resources/avatar.png";
}
private IEnumerator RotateCoin(int arg, bool playSound)
{
if (playSound)
{
PlaySound(Coins[arg].transform, Sounds.Coin.Flip);
}
float f = 0;
// Makes highlight invisible.
CoinHighlightableTransforms[arg].localScale = new Vector3(0, 0, 0);
while (f <= 1)
{
float angle = Easing.OutQuart(f, 0, 1, 1) * 180,
distance = (Mathf.Sin(f * Mathf.PI) * Mathf.PI) + 0.55f;
ApplyRotation(arg, angle, distance);
f += 1 / 64f;
yield return(new WaitForSecondsRealtime(0.01f));
}
// Makes highlight visible again.
CoinHighlightableTransforms[arg].localScale = new Vector3(1.1f, 1.1f, 0.1f);
// Since we flip a coin, we naturally need to flip the boolean.
coinStates[arg] = !coinStates[arg];
if (IsSolved)
{
yield break;
}
if (IsCorrect)
{
PlaySound(Coins[arg].transform, Sounds.Coin.Solve);
Solve("The correct coin was flipped. Module solved!");
souvenirCoin = ToCoordinate(arg);
Light.StartCoroutine(Light.Solve());
for (int i = 0; i < 64; i++)
{
int[] coinFlips = Enumerable.Range(0, 64).Where(j => (j % 8) + (j / 8) == i).ToArray();
foreach (int flip in coinFlips)
{
StartCoroutine(RotateCoin(flip, false));
yield return(new WaitForSecondsRealtime(1 / 32f));
}
}
}
else
{
PlaySound(Coins[arg].transform, Sounds.Coin.Strike);
Strike("Coin {0} was flipped, making the arrangement {1}, strike!".Form(ToCoordinate(arg), CoinValues.Select(n => n % 2 == 1 ? "1" : "0").Join("")),
"One of the answers is now {1}. (chess-coordinates)".Form(CoinValues.Select(n => n % 2 == 1 ? "1" : "0").Join(""), ToCoordinate(GetExampleAnswer())));
}
}
