public async Task Buy(string itemname, int quantity = 1)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var item = db.Items.AsQueryable().Where(i => i.Id.ToLower() == itemname.ToLower()).FirstOrDefault();
if (item != null)
{
if (account.AddToInventory(item, quantity))
{
if (account.SubtractBalance(item.Price * quantity))
{
if (item.Id.ToLower() == "bitcoin_miner")
{
cooldowns.Collect = new DateTime();
db.Update(cooldowns);
}
db.Update(account);
await ReplyAsync("Item purchased!");
}
else
{
account.RemoveFromInventory(item, quantity);
db.Update(account);
await ReplyAsync("You can't afford that item!");
}
await db.SaveChangesAsync();
}
else
{
await ReplyAsync("You have reached the item limit for that item!");
}
}
else
{
await ReplyAsync("Item was not found!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
public async Task Collect()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
if (account.Inventory.ContainsKey("bitcoin_miner"))
{
var collect = cooldowns.Collect;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(collect, "h", _collectCooldown);
if (isCooledDown)
{
var collected = _collectAmount * account.Inventory["bitcoin_miner"];
account.AddBalance(collected);
cooldowns.Collect = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync($"You've collected {collected} Kredits!");
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, collect.AddHours(_collectCooldown));
await ReplyAsync($"You can only collect once every {_collectCooldown} hours!\n" +
$"You still have to wait for {cooldown}!");
}
}
else
{
await ReplyAsync("You dont generate any passive income yet! Buy a device from the store does!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
public async Task <IActionResult> ChooseCurrency(List <Currency> currencies)
{
foreach (var item in currencies)
{
if (item.Checked)
{
Currency currency = await _context.Currencies.FirstAsync(value => value.CurrencyId == item.CurrencyId);
currency.Quantity = currency.Quantity + 1;
_context.Update(currency);
await _context.SaveChangesAsync();
}
}
return(RedirectToAction("Index"));
}
public async Task EditMeme(string name, [Remainder] string content)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var meme = db.Memes.Find(name);
if (meme != null)
{
meme.Content = content;
db.Update(meme);
await db.SaveChangesAsync();
await ReplyAsync($"Meme '{name}' was updated!");
}
else
{
await ReplyAsync($"Meme '{name}' does not exist!");
}
}
}
public async Task Work()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var pay = _workAmount;
if (account.Inventory.ContainsKey("working_tools"))
{
pay += (25 * account.Inventory["working_tools"]);
}
if (account.Inventory.ContainsKey("doctors_license"))
{
pay *= (1 + account.Inventory["doctors_license"]);
}
var work = cooldowns.Work;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(work, "m", _workCooldown);
if (isCooledDown)
{
var rng = new Random();
var randNr = rng.Next(0, 3);
if (randNr == 0 && account.Inventory.ContainsKey("vaccine"))
{
randNr = 1;
}
if (randNr > 0)
{
account.AddBalance(pay);
cooldowns.Work = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync($"You've earned {pay} Kredits!");
}
else
{
cooldowns.Work = DateTime.Now;
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync("You got covid and could not show up to work. Unlucky, I guess.");
}
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, work.AddMinutes(_workCooldown));
await ReplyAsync($"You can only work once every {_workCooldown} minutes!\n" +
$"You still have to wait for {cooldown}!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
public async Task StartTrivia()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
if (!Running)
{
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var lastTrivia = cooldowns.Trivia;
var cooldownHandler = new CooldownHandler();
if (account.Inventory.ContainsKey("trivia_license"))
{
var isCooledDown = cooldownHandler.IsCooledDown(lastTrivia, "m", _triviaCooldown);
if (isCooledDown)
{
Running = true;
cooldowns.Trivia = DateTime.Now;
db.Update(cooldowns);
await db.SaveChangesAsync();
var response = await Client.GetAsync(TriviaUrl);
var responseString = await response.Content.ReadAsStringAsync();
var responseJson = JObject.Parse(responseString);
var score = new Dictionary <ulong, int>();
var stopwatch = new Stopwatch();
await ReplyAsync("A trivia session is starting in 30 seconds...");
await Task.Delay(10000);
await ReplyAsync("A trivia session is starting in 20 seconds...");
await Task.Delay(10000);
await ReplyAsync("A trivia session is starting in 10 seconds...");
await Task.Delay(7000);
await ReplyAsync("A trivia session is starting in 3 seconds...");
await Task.Delay(1000);
await ReplyAsync("A trivia session is starting in 2 seconds...");
await Task.Delay(1000);
await ReplyAsync("A trivia session is starting in 1 seconds...");
await Task.Delay(1000);
await ReplyAsync("Trivia is starting!");
foreach (var result in responseJson["results"])
{
await Task.Delay(2000);
await ReplyAsync(HttpUtility.HtmlDecode(result["question"].ToString()));
this.result = result;
await Task.Delay(2000);
var answers = new List <string>();
answers.Add(result["correct_answer"].ToString());
foreach (var incorrectAnswer in result["incorrect_answers"])
{
answers.Add((string)incorrectAnswer);
}
answers = answers.OrderBy(a => Guid.NewGuid()).ToList();
var answersMessage = string.Join(", ", answers.ToArray());
await ReplyAsync("Answers: " + HttpUtility.HtmlDecode(answersMessage));
Context.Client.MessageReceived += tryAnswer;
stopwatch.Start();
var timeout = false;
while (winnerId == 0)
{
if (stopwatch.ElapsedMilliseconds > 15000)
{
timeout = true;
break;
}
}
stopwatch.Stop();
stopwatch.Reset();
Context.Client.MessageReceived -= tryAnswer;
if (timeout)
{
var correctAnswer = HttpUtility.HtmlDecode((string)result["correct_answer"]);
await ReplyAsync($"The answer was: {correctAnswer}!");
await ReplyAsync("No answer was found, skipping to next question!");
continue;
}
await ReplyAsync($"<@{winnerId}> has found the correct answer!");
if (score.ContainsKey(winnerId))
{
score[winnerId]++;
}
else
{
score.Add(winnerId, 1);
}
winnerId = 0;
if (score.ContainsValue(4) || result == responseJson["results"].Last)
{
break;
}
}
var sortedScores = score.OrderBy(s => s.Value).ToList();
var winners = "";
foreach (var points in sortedScores)
{
winners += $"<@{points.Key}> : {points.Value} points\n";
}
var embed = new EmbedBuilder();
embed.WithColor(new Color(0, 255, 0));
embed.WithTitle("Trivia score");
embed.WithDescription(winners);
await ReplyAsync("", false, embed.Build());
Running = false;
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, lastTrivia.AddMinutes(_triviaCooldown));
await ReplyAsync($"You can only start a trivia session once every {_triviaCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("You can't start a trivia session without a license! Check the $shop.");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
else
{
await ReplyAsync("A trivia session is already running!");
}
}
public async Task Rob(IUser user)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
if (user.Id != Context.Message.Author.Id)
{
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
var targetAccount = db.UserAccounts.AsQueryable().Where(u => u.Id == user.Id).FirstOrDefault();
var targetCooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == user.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
if (account.Inventory.ContainsKey("beat_stick"))
{
if (targetAccount != null && targetCooldowns != null)
{
var rob = cooldowns.Rob;
var robbed = targetCooldowns.Robbed;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(rob, "m", _robCooldown);
var isCooledDownTarget = cooldownHandler.IsCooledDown(robbed, "m", _robCooldown);
if (isCooledDown)
{
if (isCooledDownTarget)
{
var rng = new Random();
var robAmount = rng.Next(_minRob, _maxRob);
if (rng.Next(0, 3) > 0)
{
robAmount = (targetAccount.Balance >= robAmount) ? robAmount : targetAccount.Balance;
account.AddBalance(robAmount);
targetAccount.SubtractBalance(robAmount);
await ReplyAsync($"You stole: {robAmount} Kredits!");
}
else
{
robAmount = (account.Balance >= robAmount) ? robAmount : account.Balance;
account.SubtractBalance(robAmount);
targetAccount.AddBalance(robAmount);
await ReplyAsync($"You were beaten up and lost: {robAmount} Kredits!");
}
cooldowns.Rob = DateTime.Now;
targetCooldowns.Robbed = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
db.Update(targetAccount);
db.Update(targetCooldowns);
await db.SaveChangesAsync();
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, robbed.AddMinutes(_robCooldown));
await ReplyAsync($"Your target can only be robbed once every {_robCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, rob.AddMinutes(_robCooldown));
await ReplyAsync($"You can only rob once every {_robCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("Your target does not have an account yet!");
}
}
else
{
await ReplyAsync("You need a beat stick to rob people with!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
else
{
await ReplyAsync("You can't rob yourself you idiota!");
}
}
public async Task SpinRoulette(int bet)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (bet >= _minWager && bet <= _maxWager)
{
if (account != null && cooldowns != null)
{
if (bet <= account.Balance)
{
var lastRoulette = cooldowns.Roulette;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(lastRoulette, "s", _rouletteCooldown);
if (isCooledDown)
{
var rng = new Random();
if (rng.Next(0, 2) > 0)
{
account.AddBalance(bet);
await ReplyAsync($"You won: {bet} Kredits!");
}
else
{
account.SubtractBalance(bet);
await ReplyAsync($"You lost: {bet} Kredits!");
}
cooldowns.Roulette = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, lastRoulette.AddSeconds(_rouletteCooldown));
await ReplyAsync($"You can only roulette once every {_rouletteCooldown} seconds! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("You can't afford that bet!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
else
{
await ReplyAsync($"Wager between {_minWager}-{_maxWager} Kredits!");
}
}
}
