public Dictionary<ExchangeType, Currency> GetCurrencyDictionary(CoinType exchangeType)
{
Dictionary<ExchangeType, Currency> currencyDict = new Dictionary<ExchangeType, Currency>();
currenciesDictionary.TryGetValue(exchangeType, out currencyDict);
return currencyDict;
}
/// <summary>
/// Gets all the pub keys contained in this wallet.
/// </summary>
/// <param name="coinType">Type of the coin.</param>
/// <returns></returns>
public IEnumerable <Script> GetAllPubKeysByCoinType(CoinType coinType)
{
List <HdAccount> accounts = this.GetAccountsByCoinType(coinType).ToList();
foreach (Script script in accounts.SelectMany(x => x.ExternalAddresses).Select(x => x.ScriptPubKey))
{
yield return(script);
}
foreach (Script script in accounts.SelectMany(x => x.InternalAddresses).Select(x => x.ScriptPubKey))
{
yield return(script);
}
}
public static BitcoinCoinProperties GetCoinProperties(CoinType coin, string algorithm = null)
{
if (coin == CoinType.DGB)
{
return(GetDigiByteProperties(algorithm));
}
else if (coin == CoinType.XVG)
{
return(GetVergeProperties(algorithm));
}
coinProperties.TryGetValue(coin, out var props);
return(props);
}
public SmartContractWalletController(
IBroadcasterManager broadcasterManager,
IConnectionManager connectionManager,
ILoggerFactory loggerFactory,
Network network,
IWalletManager walletManager)
{
this.broadcasterManager = broadcasterManager;
this.connectionManager = connectionManager;
this.coinType = (CoinType)network.Consensus.CoinType;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.network = network;
this.walletManager = walletManager;
}
public WalletTransactionHandler(
ILoggerFactory loggerFactory,
ConcurrentChain chain,
IWalletManager walletManager,
IWalletFeePolicy walletFeePolicy,
Network network)
{
this.chain = chain;
this.walletManager = walletManager;
this.walletFeePolicy = walletFeePolicy;
this.network = network;
this.coinType = (CoinType)network.Consensus.CoinType;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
/// <summary>
/// Gets all the transactions by coin type.
/// </summary>
/// <param name="coinType">Type of the coin.</param>
/// <returns></returns>
public IEnumerable <TransactionData> GetAllTransactionsByCoinType(CoinType coinType)
{
List <HdAccount> accounts = this.GetAccountsByCoinType(coinType).ToList();
foreach (TransactionData txData in accounts.SelectMany(x => x.ExternalAddresses).SelectMany(x => x.Transactions))
{
yield return(txData);
}
foreach (TransactionData txData in accounts.SelectMany(x => x.InternalAddresses).SelectMany(x => x.Transactions))
{
yield return(txData);
}
}
private static Coin RandomCoin(Key[] bobs, Money amount, CoinType type)
{
if (bobs.Length == 1)
{
var bob = bobs[0];
if (type == CoinType.Normal)
{
return(new Coin(new uint256(RandomUtils.GetBytes(32)), 0, amount, bob.PubKey.Hash.ScriptPubKey));
}
if (type == CoinType.P2WPKH)
{
return(new Coin(new uint256(RandomUtils.GetBytes(32)), 0, amount, bob.PubKey.WitHash.ScriptPubKey));
}
if (type == CoinType.P2SH)
{
return(new Coin(new uint256(RandomUtils.GetBytes(32)), 0, amount, bob.PubKey.ScriptPubKey.Hash.ScriptPubKey).ToScriptCoin(bob.PubKey.ScriptPubKey));
}
if (type == CoinType.SegwitP2SH)
{
return(new Coin(new uint256(RandomUtils.GetBytes(32)), 0, amount, bob.PubKey.ScriptPubKey.WitHash.ScriptPubKey.Hash.ScriptPubKey).ToScriptCoin(bob.PubKey.ScriptPubKey));
}
if (type == CoinType.Segwit)
{
return(new Coin(new uint256(RandomUtils.GetBytes(32)), 0, amount, bob.PubKey.ScriptPubKey.WitHash.ScriptPubKey).ToScriptCoin(bob.PubKey.ScriptPubKey));
}
throw new NotSupportedException();
}
else
{
while (type == CoinType.Normal || type == CoinType.P2WPKH)
{
type = (CoinType)(RandomUtils.GetUInt32() % 5);
}
var script = PayToMultiSigTemplate.Instance.GenerateScriptPubKey((int)(1 + (RandomUtils.GetUInt32() % bobs.Length)), bobs.Select(b => b.PubKey).ToArray());
if (type == CoinType.P2SH)
{
return(new Coin(new uint256(RandomUtils.GetBytes(32)), 0, amount, script.Hash.ScriptPubKey).ToScriptCoin(script));
}
if (type == CoinType.SegwitP2SH)
{
return(new Coin(new uint256(RandomUtils.GetBytes(32)), 0, amount, script.WitHash.ScriptPubKey.Hash.ScriptPubKey).ToScriptCoin(script));
}
if (type == CoinType.Segwit)
{
return(new Coin(new uint256(RandomUtils.GetBytes(32)), 0, amount, script.WitHash.ScriptPubKey).ToScriptCoin(script));
}
throw new NotSupportedException();
}
}
/// <summary>
/// 显示抛硬币面板
/// </summary>
public void ShowTossCoinPanel(bool showSelectCoinPanel, Action <CoinType, CoinType> actionTossCoin, CoinType coinType = CoinType.Unknown)
{
tossCoinPanel.SetActive(true);
this.actionTossCoin = actionTossCoin;
if (showSelectCoinPanel)
{
tossCoinPanel.transform.GetChild(0).gameObject.SetActive(true);
tossCoinPanel.transform.GetChild(1).gameObject.SetActive(false);
}
else
{
tossCoinPanel.transform.GetChild(0).gameObject.SetActive(false);
tossCoinPanel.transform.GetChild(1).gameObject.SetActive(true);
StringResConfig stringResConfig = ConfigManager.GetConfigByName("StringRes") as StringResConfig;
Text playInfoText = tossCoinPanel.transform.GetChild(1).GetChild(0).gameObject.GetComponent <Text>();
switch (coinType)
{
case CoinType.Unknown:
playInfoText.text = "";
break;
case CoinType.Front:
playInfoText.text = stringResConfig.GetRecordById(19).value + "正面";
break;
case CoinType.Back:
playInfoText.text = stringResConfig.GetRecordById(19).value + "反面";
break;
default:
break;
}
}
CoinType resultCoinType = (CoinType)UnityEngine.Random.Range(1, 3);
Sprite coinSprite = tossCoinPanel.transform.GetChild(0).GetChild((int)resultCoinType).GetChild(0).gameObject.GetComponent <Image>().sprite;
tossCoinPanel.transform.GetChild(1).GetChild(1).gameObject.GetComponent <Image>().sprite = coinSprite;
TimerFunction timerFunction = new TimerFunction();
timerFunction.SetFunction(1, () =>
{
tossCoinPanel.SetActive(false);
actionTossCoin(coinType, resultCoinType);
});
GameManager.AddTimerFunction(timerFunction);
}
public ResponseMessage <string> transfer(string orderId, BigDecimal amount, CoinType coinType, string subCoinType, string address, string memo)
{
string callbackUrl = host + "/bipay/notify";
try
{
ResponseMessage <string> resp = biPayClient.transfer(orderId, amount, coinType.getCode(), subCoinType, address, callbackUrl, memo);
return(resp);
}
catch (Exception e)
{
e.printStackTrace();
}
return(ResponseMessage.error("提交转币失败"));
}
public CoinInfo GetCoinInfo(IDbConnection con, CoinType coinType)
{
logger.LogInvoke();
var query = "SELECT * FROM coin_info WHERE cointype = @coin ";
var results = con.Query <Entities.CoinInfo>(query, new { coin = coinType.ToString() })
.Select(mapper.Map <CoinInfo>)
.ToArray();
if (results == null || results.Length == 0)
{
return(null);
}
return(results[0]);
}
/**
* 创建币种地址
* @param coinType
* @return
*/
public Address CreateCoinAddress(CoinType coinType)
{
string callbackUrl = host + "/bipay/notify";
try
{
ResponseMessage <Address> resp = udunClient.CreateCoinAddress(coinType.code, callbackUrl);
return(resp.data);
}
catch (Exception e)
{
e.printStackTrace();
}
return(null);
}
private void InsertCoin(CoinType coinType)
{
if (coinType == CoinType.Dime)
{
_amountInDollars += 0.1M;
}
else if (coinType == CoinType.Quarter)
{
_amountInDollars += 0.25M;
}
else if (coinType == CoinType.Nickel)
{
_amountInDollars += 0.05M;
}
}
private static void Main(string[] args)
{
CoinType coinType = GetCoinType(args);
Console.WindowWidth = 150;
Console.WriteLine("Bitcoin Address Generator");
Console.WriteLine("=========================");
Console.WriteLine();
GenerateAddress(coinType);
Console.WriteLine("Press any key to quit...");
Console.ReadKey(true);
}
private static (decimal rest, int coinAmount) GetCoinChange(
this decimal val,
CoinType coinType)
{
var coinTypeVal = coinType.ToDecimal();
var coins = 0;
while (val >= coinTypeVal)
{
coins = coins + 1;
val = val - coinTypeVal;
}
return(val, coins);
}
public WalletTransactionHandler(
ILoggerFactory loggerFactory,
IWalletManager walletManager,
IWalletFeePolicy walletFeePolicy,
Network network)
{
this.Network = network;
this.walletManager = walletManager;
this.walletFeePolicy = walletFeePolicy;
this.coinType = (CoinType)network.Consensus.CoinType;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.privateKeyCache = new MemoryCache(new MemoryCacheOptions()
{
ExpirationScanFrequency = new TimeSpan(0, 1, 0)
});
}
private CoinInfo GetCoinInfoFromCryptoCompare(CoinType coinType)
{
var url = "https://min-api.cryptocompare.com/data/price?fsym=" + coinType.ToString() + "&tsyms=BTC,USD";
var json = new WebClient().DownloadString(url);
var response = JsonConvert.DeserializeObject <CryoptoCompareResponse>(json);
return(new CoinInfo
{
CoinType = coinType,
Name = coinType.ToString(),
CoinMarketCapId = 0,
PriceUSD = response.USD,
PriceBTC = response.BTC,
Updated = DateTime.Now
});
}
public SmartContractTransactionService(
Network network,
IWalletManager walletManager,
IWalletTransactionHandler walletTransactionHandler,
IMethodParameterStringSerializer methodParameterStringSerializer,
ICallDataSerializer callDataSerializer,
IAddressGenerator addressGenerator)
{
this.network = network;
this.walletManager = walletManager;
this.walletTransactionHandler = walletTransactionHandler;
this.methodParameterStringSerializer = methodParameterStringSerializer;
this.callDataSerializer = callDataSerializer;
this.coinType = (CoinType)network.Consensus.CoinType;
this.addressGenerator = addressGenerator;
}
public WalletManager(ILoggerFactory loggerFactory, ConnectionManager connectionManager, Network network, ConcurrentChain chain,
NodeSettings settings, DataFolder dataFolder)
{
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.Wallets = new List <Wallet>();
this.connectionManager = connectionManager;
this.network = network;
this.coinType = (CoinType)network.Consensus.CoinType;
this.chain = chain;
this.settings = settings;
this.dataFolder = dataFolder;
// register events
this.TransactionFound += this.OnTransactionFound;
}
private void SetActualPlayer()
{
switch (actualPlayer)
{
case CoinType.NoOne:
case CoinType.X:
actualPlayer = CoinType.O;
break;
case CoinType.O:
actualPlayer = CoinType.X;
break;
}
Console.WriteLine($"E' il turno del giocatore {actualPlayer.ToString()}");
}
private void SpawnCoins(ChunkDesign _chunkDesign, Transform _chunkParent)
{
List <Vector3> _coinLocalPositions = _chunkDesign.GetCoinLocalPositions();
List <CoinType> _coinTypes = CoinSpawnChancesByTimeLibrary.Instance.GetCoinTypesToSpawn(_coinLocalPositions.Count, Progression.Timer);
for (int i = 0; i < _coinTypes.Count; i++)
{
CoinType _coinType = _coinTypes[i];
Vector3 _localPosition = _coinLocalPositions[i];
GameObject _coinPrefab = CoinPrefabByCoinTypeLibrary.Instance.GetCoinPrefab(_coinType);
GameObject _coinGameObject = ObjectPool.Instance.GetObjectForType(_coinPrefab.name, false);
_coinGameObject.transform.parent = _chunkParent.transform;
_coinGameObject.transform.position = new Vector3(_localPosition.x, _localPosition.y, _localPosition.z + _chunkParent.transform.position.z);
}
}
public static (double?coin, double?USD, double?RUB) GetProfit(CoinType ct)
{
string name = ct switch
{
CoinType.ETC => "EthereumClassic",
CoinType.ETH => "Ethereum",
CoinType.RVN => "Ravencoin",
_ => ""
};
RootObject ro = null;
try { ro = Profits.Where(x => x.name == name).First(); } catch { return(null, null, null); }
return(ro.rewardsInDay, ro.revenueInDayUSD, ro.revenueInDayUSD *USDcost);
}
public string SendRequest(CoinType coin, string fullAddress)
{
string data = String.Empty;
byte[] postData = Encoding.ASCII.GetBytes(data);
HttpWebRequest request = GetRequest(coin, postData, fullAddress);
using (var stream = request.GetRequestStream())
{
stream.Write(postData, 0, postData.Length);
}
var response = (HttpWebResponse)request.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
return(responseString);
}
public FederationWalletController(
ILoggerFactory loggerFactory,
IFederationWalletManager walletManager,
IFederationWalletSyncManager walletSyncManager,
IConnectionManager connectionManager,
Network network,
ConcurrentChain chain,
IDateTimeProvider dateTimeProvider)
{
this.walletManager = walletManager;
this.walletSyncManager = walletSyncManager;
this.connectionManager = connectionManager;
this.coinType = (CoinType)network.Consensus.CoinType;
this.chain = chain;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
/// <summary>
/// Call API and GET list of account wallet addresses
/// </summary>
/// <returns></returns>
public List <AccountWallet> GetAccountWalletList()
{
NameValueCollection nameValueCollection = new NameValueCollection();
string apiURL = "";
try
{
nameValueCollection.Add("AccountGuid", Application.Current.Properties["AccountID"].ToString());
apiURL = APIConstants.APIURL + APIEndpoints.GetAccountWallet;
List <AccountWallet> accountWalletList = DownloadSerializedJSONData <List <AccountWallet> >(apiURL, nameValueCollection);
List <AccountWallet> accountWalletListSupported = new List <AccountWallet>();
// Update all AccountGuid properties in case they are returned null when there is no pre-existing wallet addresses saved for this account
accountWalletList = accountWalletList.Select(c => { c.AccountGuid = (Guid)Application.Current.Properties["AccountID"]; return(c); }).ToList();
// Update coin logo and build supported wallet list
foreach (AccountWallet accountWallet in accountWalletList)
{
// Skip unsupported coin types
if (Enum.IsDefined(typeof(CoinType), accountWallet.CoinType) == false)
{
continue;
}
CoinType coinType = CoinType.UNDEFINED;
Enum.TryParse(accountWallet.CoinType, out coinType);
CoinLogos.CoinLogoDictionary.TryGetValue(coinType, out string logoSourceLocation);
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, logoSourceLocation);
if (accountWallet.WalletAddress == null)
{
accountWallet.WalletAddress = "";
}
accountWallet.CoinLogo = path;
accountWalletListSupported.Add(accountWallet);
}
return(accountWalletListSupported);
}
catch (Exception e)
{
logger.Error(e, $"Unable to retrieve the account wallet list for '{Application.Current.Properties["AccountID"].ToString()}' from '{apiURL}'");
return(new List <AccountWallet>());
}
}
/// <summary>
/// Creates a new coin, dropping reference to the previouse and showing it on the canvas.
/// </summary>
/// <param name="coinType">Type of coin to use.</param>
/// <param name="gridSize">The size of one grid.</param>
public void Create(CoinType coinType, Size gridSize)
{
CoinType = coinType;
switch (coinType)
{
case CoinType.None:
case CoinType.Red:
Coin = new Image()
{
Width = gridSize.Width,
Height = gridSize.Height,
Source = redCoin
};
break;
case CoinType.Blue:
Coin = new Image()
{
Width = gridSize.Width,
Height = gridSize.Height,
Source = blueCoin
};
break;
}
canvas.Children.Add(Coin);
location = new Point(location.X, 0);
Move(location, gridSize, TimeSpan.FromMilliseconds(1));
if (coinType == CoinType.None || deleteNext)
{
deleteNext = false;
Delete();
}
else
{
switch (coinType)
{
case CoinType.Red:
RedTurn?.Invoke(this, null);
break;
case CoinType.Blue:
BlueTurn?.Invoke(this, null);
break;
}
}
}
private void buttonGenerateAddress_Click(object sender, EventArgs e)
{
BitcoinAddressGenerator addressGenerator = new BitcoinAddressGenerator();
CoinType coinType = (CoinType)Enum.Parse(typeof(CoinType), (string)this.comboBoxCoinTypeGenerate.SelectedItem);
AddressInfo addressInfo = addressGenerator.GenerateAddress(coinType);
this.textBoxPrivateKeyHex.Text = addressInfo.PrivateKeyHex;
this.textBoxPrivateKeyWif.Text = addressInfo.PrivateKeyWif;
this.textBoxPublicKeyHex.Text = addressInfo.PublicKeyHex;
this.textBoxPublicKeyHash.Text = addressInfo.PublicKeyHash;
this.textBoxAddress.Text = addressInfo.Address;
this.labelAddress.Text = $@"Address ({coinType:G})";
this.comboBoxCoinTypeBlockExplorer.SelectedIndex = this.comboBoxCoinTypeGenerate.SelectedIndex;
this.labelStatus.ForeColor = Color.Green;
this.labelStatus.Text = @"Address generation successful!";
}
/// <summary>
/// Lets the game engine communicate an end result to the user via the game chat.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void GameMessage_Recieved(object sender, CoinType e)
{
switch (e)
{
case CoinType.None:
Application.Current.Dispatcher.Invoke((Action <object>)AddMessage, new Message($"The Game has ended in a tie!", "Server"));
break;
case CoinType.Red:
Application.Current.Dispatcher.Invoke((Action <object>)AddMessage, new Message($"You have won!", "Server"));
break;
case CoinType.Blue:
Application.Current.Dispatcher.Invoke((Action <object>)AddMessage, new Message($"Your opponent has won!", "Server"));
break;
}
}
public ATransaction CreateTransaction(decimal amount, CoinType coinType, Party toParty, int?index = null)
{
ATransaction tx;
if (index != null)
{
tx = new ATransaction(amount, toParty, Transactions[0]);
}
else
{
tx = new ATransaction(amount, toParty);
}
tx.Amount = amount;
tx.CoinType = coinType;
Transactions.Add(tx);
return(tx);
}
public async Task <CoinPriceResponse> FetchCoinPriceAsync()
{
// Fetch preferred coin from in-memory cache
CoinType preferredCoin = _userRepository.FetchPreferredCoin();
// Fetch price data from coin
PriceResponse response = await _coinPriceGateway.FetchCoinPriceAsync(preferredCoin).ConfigureAwait(false);
// Map and return response
return(new CoinPriceResponse
{
CoinType = preferredCoin,
Rate = response.Rate,
Bid = response.Bid,
Ask = response.Ask
});
}
/// <summary>
/// Gets the first account that contains no transaction.
/// </summary>
/// <returns>An unused account.</returns>
public HdAccount GetFirstUnusedAccount(CoinType coinType)
{
// Get the accounts root for this type of coin.
AccountRoot accountsRoot = this.AccountsRoot.Single(a => a.CoinType == coinType);
if (accountsRoot.Accounts.Any())
{
// Get an unused account.
HdAccount firstUnusedAccount = accountsRoot.GetFirstUnusedAccount();
if (firstUnusedAccount != null)
{
return(firstUnusedAccount);
}
}
return(null);
}
public FederationWalletManager(
ILoggerFactory loggerFactory,
Network network,
ChainIndexer chainIndexer,
DataFolder dataFolder,
IWalletFeePolicy walletFeePolicy,
IAsyncLoopFactory asyncLoopFactory,
INodeLifetime nodeLifetime,
IDateTimeProvider dateTimeProvider,
IFederationGatewaySettings federationGatewaySettings,
IWithdrawalExtractor withdrawalExtractor,
IBroadcasterManager broadcasterManager = null) // no need to know about transactions the node broadcasted
{
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(network, nameof(network));
Guard.NotNull(chainIndexer, nameof(chainIndexer));
Guard.NotNull(dataFolder, nameof(dataFolder));
Guard.NotNull(walletFeePolicy, nameof(walletFeePolicy));
Guard.NotNull(asyncLoopFactory, nameof(asyncLoopFactory));
Guard.NotNull(nodeLifetime, nameof(nodeLifetime));
Guard.NotNull(federationGatewaySettings, nameof(federationGatewaySettings));
Guard.NotNull(withdrawalExtractor, nameof(withdrawalExtractor));
this.lockObject = new object();
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.network = network;
this.coinType = (CoinType)network.Consensus.CoinType;
this.chainIndexer = chainIndexer;
this.asyncLoopFactory = asyncLoopFactory;
this.nodeLifetime = nodeLifetime;
this.fileStorage = new FileStorage <FederationWallet>(dataFolder.WalletPath);
this.broadcasterManager = broadcasterManager;
this.dateTimeProvider = dateTimeProvider;
this.federationGatewaySettings = federationGatewaySettings;
this.withdrawalExtractor = withdrawalExtractor;
this.outpointLookup = new Dictionary <OutPoint, TransactionData>();
this.isFederationActive = false;
// register events
if (this.broadcasterManager != null)
{
this.broadcasterManager.TransactionStateChanged += this.BroadcasterManager_TransactionStateChanged;
}
}
public Coin(float x, float y, int coinValue, CoinType coinType, float targetX = 0, float targetY = 0)
: base(x, y)
{
this.CoinType = coinType;
this.ScaleX = 0.7f;
this.ScaleY = 0.7f;
this.CoinValue = coinValue;
if (targetX != 0 && targetY != 0)
{
SpawnTarget = new Vector2(targetX, targetY);
CoinState = State.Spawning;
}
else
{
CoinState = State.Active;
}
}
public void AddCoin(CoinType coinType)
{
switch (coinType)
{
case CoinType.One:
CoinsInBox.CoinsOne.Add(1);
break;
case CoinType.Two:
CoinsInBox.CoinsTwo.Add(1);
break;
case CoinType.Five:
CoinsInBox.CoinsFive.Add(1);
break;
case CoinType.Ten:
CoinsInBox.CoinsTen.Add(1);
break;
}
}
public void TakeCoin(CoinType coinType)
{
//coinBronzeAmount += (int)coinType;
switch (coinType)
{
case CoinType.Gold:
coinGoldAmount++;
break;
case CoinType.Silver:
coinSilverAmount++;
break;
case CoinType.Bronze:
default:
coinBronzeAmount++;
break;
}
}
public void SetCurrencyValue(CoinType coinType, ExchangeType exchangeType, Currency currency)
{
currenciesDictionary[coinType][exchangeType] = currency;
}
public void CustomerPayment(CoinType c, int quantity)
{
if (_customerWallet.Coins[c] <= 0) return;
lock (_syncRoot)
{
_vmWallet.Coins[c] += quantity;
_customerWallet.Coins[c] -= quantity;
_customerBalance = _customerBalance + quantity * (int)c;
}
}
/// <summary>
/// Deposits the amount of the coin type provided into the bank. Optional third parameter will
/// move the coin from the regular bank to the shared bank if true.
/// </summary>
/// <param name="type">coin type</param>
/// <param name="amount">coin amount</param>
/// <param name="useBank">use bank as source</param>
/// <returns></returns>
public bool SharedBankDeposit(CoinType type, int amount, bool useBank = false)
{
Trace.WriteLine(String.Format("Character:BankDeposit({0}, {1}, {2})", type,
amount.ToString(CultureInfo.InvariantCulture), useBank));
return !useBank ? this.ExecuteMethod("BankDeposit", type.ToString()[0].ToString(CultureInfo.InvariantCulture),
amount.ToString(CultureInfo.InvariantCulture)) : this.ExecuteMethod("BankDeposit",
type.ToString()[0].ToString(CultureInfo.InvariantCulture), amount.ToString(CultureInfo.InvariantCulture), "FromBank");
}
/// <summary>
/// Withdraws the specified coin type and amount from the shared bank.
/// </summary>
/// <param name="type">coin type</param>
/// <param name="amount">coin amount</param>
/// <returns>call success</returns>
public bool SharedBankWithdraw(CoinType type, int amount)
{
Trace.WriteLine(String.Format("Character:SharedBankWithdraw({0}, {1})", type,
amount.ToString(CultureInfo.InvariantCulture)));
return this.ExecuteMethod("SharedBankWithdraw", type.ToString()[0].ToString(CultureInfo.InvariantCulture),
amount.ToString(CultureInfo.InvariantCulture));
}
void Construct(float x=0, float y=0, CoinType coinType=CoinType.Copper, int coinValue=0)
{
this.Pos = new Vector2(x, y);
this.CoinType = coinType;
this.ScaleX = 0.7f;
this.ScaleY = 0.7f;
this.CoinValue = coinValue;
this.EntityCollisionEnabled = false;
this.CollisionGroup = "Shadow";
}
public Coin(float x, float y, int coinValue, CoinType coinType)
{
Construct(x, y, coinType, coinValue);
}
public Currency GetCurrencyValue(CoinType coinType, ExchangeType exchangeType)
{
return currenciesDictionary[coinType][exchangeType];
}
public Coins(CoinType coinType, int amount)
: base(coinType)
{
Amount = amount;
}
public Coin(CoinType type)
{
CoinType = type;
}
