public async Task Execute(object arguments, Message message)
{
var a = (Arguments)arguments;
var expDiff = RSUtil.ExpBetweenLevels(a.Level1, a.Level2);
await message.Channel.SendMessage(
$"The total experience between levels **{a.Level1}** and **{a.Level2}** " +
$"is **{expDiff.ToString("#,##0")}**");
}
private async Task <string> MakeChart(item item, int days)
{
var history = (await RSUtil.GetPriceHistory(item.Name, true))
.Reverse()
.Take(days)
.Reverse()
.ToIDictionary();
var chart = new Chart();
var chartArea = new ChartArea();
var series = new Series();
// Chart area setup
double min = history.Aggregate(int.MaxValue, (a, h) => h.Value < a ? h.Value : a);
double max = history.Aggregate(0, (a, h) => h.Value > a ? h.Value : a);
min = Math.Floor(min * 0.95);
max = Math.Ceiling(Math.Min(double.MaxValue, max * 1.05));
// Chart setup
chart.Size = new Size(539 + max.ToString("#,##0").Length * 8, 500);
chartArea.AxisX.LabelStyle.Format = days > 119 ? "MMM yyyy" : "MMM dd";
chartArea.AxisY.LabelStyle.Format = "#,##0";
chartArea.AxisX.MajorGrid.LineColor = Color.FromArgb(0x3e, 0x41, 0x46);
chartArea.AxisY.MajorGrid.LineColor = Color.FromArgb(0x3e, 0x41, 0x46);
chartArea.AxisX.LabelStyle.ForeColor = Color.FromArgb(unchecked ((int)4294967264));
chartArea.AxisY.LabelStyle.ForeColor = Color.FromArgb(unchecked ((int)4294967264));
chartArea.BackColor = Color.FromArgb(0x2e, 0x31, 0x36);
chart.BackColor = Color.FromArgb(0x2e, 0x31, 0x36);
chartArea.AxisX.LabelStyle.Font = new Font("Consolas", 8);
chartArea.AxisY.LabelStyle.Font = new Font("Consolas", 8);
chartArea.AxisY.Minimum = min;
chartArea.AxisY.Maximum = max;
chart.ChartAreas.Add(chartArea);
// Series setup
series.Name = "Series1";
series.ChartType = SeriesChartType.Line;
series.XValueType = ChartValueType.DateTime;
chart.Series.Add(series);
// bind the datapoints
chart.Series["Series1"].Points.DataBindXY(history.Keys, history.Values);
// draw!
chart.Invalidate();
// write out a file
using (var ms = new MemoryStream())
{
chart.SaveImage(ms, ChartImageFormat.Png);
return(await ImageUtil.PostToImgur(ms.ToArray()));
}
}
public async Task <object> ParseArguments(string[] args, Message message)
{
var a = new Arguments();
var optSet = new OptionSet
{
{ "c|chart=", (int?c) => a.Days = c }
};
a.Item = await RSUtil.GetItemForDynamic(string.Join(" ", optSet.Parse(args)));
// Validating
if (a.Days < 31)
{
throw new ControlledException("Chart must be greater than or equal to 31.");
}
return(a);
}
public async Task Execute(object arguments, Message message)
{
var a = (Arguments)arguments;
var table = new Table();
var temp = a.OSRS ? "OLDSCHOOL" : "RS3";
string m;
// Getting user's stats
var stats = a.OSRS
? (object)await OSRSUtil.GetStatsForUser(a.Username)
: (object)await RSUtil.GetStatsForUser(a.Username);
// Table making
table.SetTitle($"VIEWING {temp} STATS FOR {a.Username.ToUpper()}");
table.SetHeadings("Skill", "Level", "Experience", "Rank");
stats.GetType().GetProperties().ForEach(p =>
{
var stat = (Stat)p.GetMethod.Invoke(stats, null);
table.AddRow(
p.Name,
new Table.Column(stat.Level, Table.Column.Alignment.Right),
new Table.Column(stat.Exp.ToString("#,##0"), Table.Column.Alignment.Right),
new Table.Column(stat.Rank.ToString("#,##0"), Table.Column.Alignment.Right));
});
// Uploading image
if (a.Image)
{
m = await ImageUtil.PostToImgur(ImageUtil.ToImage(table.ToString()));
}
else
{
m = $"```{table}```";
}
await message.Channel.SendMessage(m);
}
private void Jump(GameEvent gameEvent)
{
if (gameEvent == GameEvent.Jump && charState.IsIdleOrMoving())
{
animator.SetBool("WallBounce", false);
EventManager.OnCharEvent(GameEvent.Jump);
InputController.jumpReleased = false;
//jumpTime = Time.time;
// Change the forward speed based on what kind of jump it is
if (charState.IsIdle())
{
animator.SetTrigger(anim_idleJump);
}
else if (charState.IsRunning())
{
animator.SetTrigger(anim_runningJump);
}
else if (charState.IsSprinting())
{
animator.SetBool(anim_sprintJump, true);
RSUtil.OrientCapsuleCollider(cCollider, false);
//Debug.Break();
}
}
//print (gameEvent);
else if (gameEvent == GameEvent.Jump && charState.IsIdleOrRunningJumping() && !hasDoubleJumped)
{
animator.SetTrigger(anim_doubleJump);
}
}
private async Task AddItem(AddArguments args, Message m)
{
using (Database db = new Database())
{
item item;
var message = "";
// Removing item already in the DB
for (var i = args.Items.Count() - 1; i >= 0; i--)
{
string itemReadable = args.Items.ElementAt(i);
int temp;
// Checking if the string is an int
if (int.TryParse(itemReadable, out temp))
{
item = await db.items.FindAsync(temp);
}
else
{
item = await db.items.FirstOrDefaultAsync(it => it.Name == itemReadable);
}
// Checking if item is in DB
if (item != null)
{
message += $"**{item.Name}** already exists in the database.\n";
args.Items.Remove(itemReadable);
}
}
var tasks = new Task <item> [args.Items.Count];
// Fetching item data
for (var i = 0; i < args.Items.Count; i++)
{
tasks[i] = RSUtil.GetItemForDynamic(args.Items.ElementAt(i));
}
// Waiting for all items to complete
await Task.Run(() => { try { Task.WaitAll(tasks); } catch (Exception) { } });
// Adding items
foreach (var t in tasks)
{
// Skipping if task errored
if (t.Status != TaskStatus.RanToCompletion)
{
continue;
}
item = t.Result;
db.items.Add(item);
message += $"**{item.Name}** has added to the database.\n";
// Removing completed from array
args.Items.Remove(item.Name);
args.Items.Remove(item.Id.ToString());
}
// Outputting message for those that errors
foreach (var s in args.Items)
{
message += $"**{s}** could not be added to the database.\n";
}
// Saving
if (await db.SaveChangesAsync() < 0)
{
message += "There was an error saving the items to the database.\n";
}
await m.Channel.SendMessage(message.Substring(0, message.Length - 1));
}
}
private void Awake ()
{
if (Instance == null)
Instance = this;
}
private async Task UpdateItem(UpdateArguments args, Message message)
{
var m = await message.Channel.SendMessage("Updating...");
using (var db = new Database())
{
// Excluding items not in the db
var updated = 0;
var runeday = await RSUtil.GetRuneday();
var total = await db.Database.SqlQuery <int>(
"SELECT COUNT(*) " +
"FROM items " +
"WHERE Id <> 0 " +
"AND UpdatedAtRD <> @p0", runeday)
.FirstAsync();
db.Database.Log = Console.WriteLine;
for (var i = 0;; i++)
{
// Getting item batch
var items = await db.Database.SqlQuery <item>(
"SELECT * " +
"FROM items " +
"WHERE Id <> 0 " +
"AND UpdatedAtRD <> @p0 " +
"LIMIT @p1, 50"
, runeday
, i * 50)
.ToListAsync();
if (items.Count <= 0)
{
break;
}
var tasks = new Task <item> [items.Count];
// Starting tasks
items.ForEachWithIndex((index, item)
=> tasks[index] = RSUtil.GetItemForId((int)item.Id, item.Name, runeday));
// Waiting for tasks to complete
await Task.Run(() =>
{
try { Task.WaitAll(tasks); } catch (Exception) {}
});
var updateQuery = "UPDATE items SET Price = (CASE";
var predicatedTasks = tasks.Where(t => t.Status == TaskStatus.RanToCompletion);
predicatedTasks.ForEach(t => updateQuery += $" WHEN Id = {t.Result.Id} THEN {t.Result.Price}");
updateQuery += " ELSE Price END), UpdatedAtRD = @p0, UpdatedAt = @p1 WHERE Id In " +
$"({string.Join(",", predicatedTasks.Select(t => t.Result.Id))});";
updated += db.Database.ExecuteSqlCommand(updateQuery
, runeday
, DateTime.Now);
await m.Edit($"Updated **{updated}**/**{total}** items.");
}
await message.Channel.SendMessage($"Item updates completed. Updated **{updated}**/**{total}** items.");
}
}
private async Task <object> ParseSearchArguments(string[] args, Message message)
{
SearchArguments a = new SearchArguments {
Orders = new List <SearchArguments.Order>()
};
FluentCommandLineParser parser = new FluentCommandLineParser();
string usernme = null;
bool helpCalled = false;
parser.Setup <AddArguments.Skill>('s', "skill")
.Callback(s => a.Skill = s)
.Required();
parser.Setup <List <string> >('u', "username")
.Required()
.Callback(u => usernme = string.Join(" ", u));
parser.Setup <bool>('i', "image")
.Callback(i => a.Image = i);
parser.Setup <int>('p', "page")
.SetDefault(1)
.Callback(p => a.Page = p);
parser.Setup <int>('l', "limit")
.SetDefault(10)
.Callback(l => a.Limit = l);
parser.Setup <int>('L', "level")
.Required()
.Callback(l => a.Level = l);
parser.Setup <List <SearchArguments.Order> >('o', "order")
.SetDefault(new List <SearchArguments.Order> {
SearchArguments.Order.Name
})
.Callback(o => a.Orders = o);
parser.Setup <bool>('?', "help")
.Callback(h => helpCalled = h);
var r = parser.Parse(args);
if (r.HasErrors || helpCalled)
{
if (!helpCalled)
{
await message.Channel.SendMessage($"```{r.ErrorText}```");
return(false);
}
await message.Channel.SendMessage(
"**Usage:**\n" +
"```!recipe search <-s|skill> <-u|username> <-L|level> [-q|query] [-p|page] [-l|limit] [-o|order]```\n" +
"**Options:**\n" +
"`-s`, `--skill` **REQUIRED**\n" +
"The skill you wish to get methods of training for.\n" +
"\n" +
"`-u`, `--username` **REQUIRED**\n" +
"Your in game name.\n" +
"\n" +
"`-L`, `--level` **REQUIRED**\n" +
"The level you wish to obtain\n" +
"\n" +
"`-p`, `--page` *OPTIONAL*\n" +
"The page of results to show.\n" +
"\n" +
"`-l`, `--limit` *OPTIONAL*\n" +
"Results per page.\n" +
"\n" +
"`-o`, `--order` *OPTIONAL*\n" +
"How the results will be ordered. Values can be Cheap, Expensive, Slow, Fast, Name, Level");
return(false);
}
// Getting username
a.RS3Stats = await RSUtil.GetStatsForUser(usernme);
return(a);
}
private async Task SearchRecipe(SearchArguments a, Message message)
{
using (var db = new Database())
{
Stat stat = a.RS3Stats.GetStatForName(a.Skill.ToString());
int levelDiff = RSUtil.ExpBetweenLevels(stat, a.Level);
var dbLookup = new Stopwatch();
var queryBuild = new Stopwatch();
var upload = new Stopwatch();
var convertText = new Stopwatch();
queryBuild.Start();
var tempQuery = db.recipes
.Where(r => r.Skill == (int)a.Skill)
.Where(r => r.Level <= stat.Level)
.Select(r => new Entity
{
Id = r.Id,
Name = r.Name,
Level = r.Level,
Exp = r.Exp,
ExpH = r.Exp * r.Units,
Number = (int)Math.Ceiling(levelDiff / r.Exp),
Cost = (db.outputs.Where(o => o.RecipeId == r.Id).Sum(o => o.Quantity * o.item.Price)
- (db.inputs.Where(i => i.RecipeId == r.Id).Sum(i => i.Quantity * i.item.Price) + r.Extra))
* Math.Ceiling(levelDiff / r.Exp),
Time = Math.Ceiling(levelDiff / r.Exp) / r.Units
});
var firstOrder = a.Orders.First();
IOrderedQueryable <Entity> query = null;
// Doing first sort
switch (firstOrder)
{
case SearchArguments.Order.Expensive:
query = tempQuery.OrderBy(r => r.Cost);
break;
case SearchArguments.Order.Fast:
query = tempQuery.OrderBy(r => r.Time);
break;
case SearchArguments.Order.Cheap:
query = tempQuery.OrderByDescending(r => r.Cost);
break;
case SearchArguments.Order.Slow:
query = tempQuery.OrderByDescending(r => r.Time);
break;
case SearchArguments.Order.Name:
query = tempQuery.OrderBy(r => r.Name);
break;
case SearchArguments.Order.Level:
query = tempQuery.OrderBy(r => r.Level);
break;
}
// Consecutive sort
for (var i = 1; i < a.Orders.Count; i++)
{
switch (firstOrder)
{
case SearchArguments.Order.Expensive:
query = query.ThenByDescending(r => r.Cost);
break;
case SearchArguments.Order.Fast:
query = query.ThenBy(r => r.Time);
break;
case SearchArguments.Order.Cheap:
query = query.ThenBy(r => r.Cost);
break;
case SearchArguments.Order.Slow:
query = query.ThenByDescending(r => r.Time);
break;
case SearchArguments.Order.Name:
query = query.ThenBy(r => r.Name);
break;
case SearchArguments.Order.Level:
query = query.ThenBy(r => r.Level);
break;
}
}
// Stopping query builder timer
queryBuild.Stop();
var pages = Math.Ceiling((decimal)await query.LongCountAsync() / a.Limit);
// Starting db lookup
dbLookup.Start();
var recipes = await query.Skip((a.Page - 1) *a.Limit)
.Take(a.Limit)
.ToListAsync();
// END OF DB LOOKUP
dbLookup.Stop();
if (!recipes.Any())
{
await message.Channel.SendMessage("No recipes found.");
return;
}
// Formatting
Table table = new Table();
table.SetTitle($"{a.Skill} Recipes ({a.Page}/{pages})");
table.SetHeadings("Id", "Name", "Level", "Xp", "Xp/H", "Number", "Cost", "Time");
recipes.ForEach(r => table.AddRow(
r.Id
, r.Name
, new Table.Column(r.Level, Table.Column.Alignment.Right)
, new Table.Column(r.Exp.ToString("#,##0.##"), Table.Column.Alignment.Right)
, new Table.Column(r.ExpH.ToString("#,##0.##"), Table.Column.Alignment.Right)
, new Table.Column(r.Number.ToString("#,##0"), Table.Column.Alignment.Right)
, new Table.Column(r.Cost.ToString("#,##0"), Table.Column.Alignment.Right)
, new Table.Column(r.Time.ToFormattedTime(), Table.Column.Alignment.Right)));
string @out = $"{table}";
// Outputing image
if (a.Image)
{
var img = convertText.TimeTask(() => ImageUtil.ToImage(@out));
var link = await upload.TimeTaskAsync(async() => await ImageUtil.PostToImgur(img));
await message.Channel.SendMessage(link + "\n" +
$"**Build Query**: {dbLookup.ElapsedMilliseconds}ms | " +
$"**Query DB**: {queryBuild.Elapsed.Milliseconds}ms | " +
$"**Convert Text**: {convertText.ElapsedMilliseconds}ms | " +
$"**Upload Image**: {upload.ElapsedMilliseconds}ms");
}
else
{
await message.Channel.SendMessage($"**Build Query**: {dbLookup.ElapsedMilliseconds}ms | " +
$"**Query DB**: {queryBuild.Elapsed.Milliseconds}ms" +
$"```{@out}```");
}
}
}
