mirror of
https://git.alee14.me/shiftos-archive/ShiftOS_TheReturn.git
synced 2025-01-23 02:12:14 +00:00
2acfa34596
It uses a meta-language and a CSharpCodeProvider on startup. I will release a tutorial on the forums soon showing how to use it. This commit also adds an extremely basic loading screen which shows while Desktop is getting everything ready. Which can take a while if you have any Python mods. Thanks, IronPython.
850 lines
28 KiB
C#
850 lines
28 KiB
C#
/*
|
|
* MIT License
|
|
*
|
|
* Copyright (c) 2017 Michael VanOverbeek and ShiftOS devs
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#define DEVEL
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using ShiftOS.Engine.Properties;
|
|
using System.IO;
|
|
using Newtonsoft.Json;
|
|
using System.IO.Compression;
|
|
|
|
using ShiftOS.Objects;
|
|
using Discoursistency.Base.Models.Authentication;
|
|
using ShiftOS.Engine.Scripting;
|
|
using ShiftOS.Objects.ShiftFS;
|
|
|
|
namespace ShiftOS.Engine
|
|
{
|
|
[Namespace("infobox", hide = true)]
|
|
[RequiresUpgrade("desktop;wm_free_placement")]
|
|
public static class InfoboxDebugCommands
|
|
{
|
|
|
|
[RequiresArgument("title")]
|
|
[RequiresArgument("msg")]
|
|
[Command("show")]
|
|
public static bool ShowInfo(Dictionary<string, object> args)
|
|
{
|
|
Desktop.InvokeOnWorkerThread(new Action(() =>
|
|
{
|
|
Infobox.Show(args["title"].ToString(), args["msg"].ToString());
|
|
}));
|
|
return true;
|
|
}
|
|
|
|
[RequiresArgument("title")]
|
|
[RequiresArgument("msg")]
|
|
[Command("yesno")]
|
|
public static bool ShowYesNo(Dictionary<string, object> args)
|
|
{
|
|
bool forwarding = TerminalBackend.IsForwardingConsoleWrites;
|
|
var fGuid = TerminalBackend.ForwardGUID;
|
|
Action<bool> callback = (result) =>
|
|
{
|
|
TerminalBackend.IsForwardingConsoleWrites = forwarding;
|
|
TerminalBackend.ForwardGUID = (forwarding == true) ? fGuid : null;
|
|
string resultFriendly = (result == true) ? "yes" : "no";
|
|
Console.WriteLine($"{SaveSystem.CurrentUser.Username} says {resultFriendly}.");
|
|
TerminalBackend.IsForwardingConsoleWrites = false;
|
|
};
|
|
Desktop.InvokeOnWorkerThread(new Action(() =>
|
|
{
|
|
Infobox.PromptYesNo(args["title"].ToString(), args["msg"].ToString(), callback);
|
|
|
|
}));
|
|
return true;
|
|
}
|
|
|
|
[RequiresArgument("title")]
|
|
[RequiresArgument("msg")]
|
|
[Command("text")]
|
|
public static bool ShowText(Dictionary<string, object> args)
|
|
{
|
|
bool forwarding = TerminalBackend.IsForwardingConsoleWrites;
|
|
var fGuid = TerminalBackend.ForwardGUID;
|
|
Action<string> callback = (result) =>
|
|
{
|
|
TerminalBackend.IsForwardingConsoleWrites = forwarding;
|
|
TerminalBackend.ForwardGUID = (forwarding == true) ? fGuid : null;
|
|
Console.WriteLine($"{SaveSystem.CurrentUser.Username} says \"{result}\".");
|
|
TerminalBackend.IsForwardingConsoleWrites = false;
|
|
};
|
|
Desktop.InvokeOnWorkerThread(new Action(() =>
|
|
{
|
|
Infobox.PromptText(args["title"].ToString(), args["msg"].ToString(), callback);
|
|
}));
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
[Namespace("audio")]
|
|
public static class AudioCommands
|
|
{
|
|
[Command("setvol", description = "Set the volume of the system audio to anywhere between 0 and 100.")]
|
|
[RequiresArgument("value")]
|
|
[RequiresUpgrade("audio_volume")]
|
|
public static bool SetVolume(Dictionary<string,object> args)
|
|
{
|
|
int val = Convert.ToInt32(args["value"].ToString());
|
|
float volume = (val / 100F);
|
|
AudioManager.SetVolume(volume);
|
|
return true;
|
|
}
|
|
[RequiresUpgrade("audio_volume")]
|
|
[Command("mute", description = "Sets the volume of the system audio to 0")]
|
|
public static bool MuteAudio()
|
|
{
|
|
AudioManager.SetVolume(0);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
[RequiresUpgrade("mud_fundamentals")]
|
|
[Namespace("mud")]
|
|
public static class MUDCommands
|
|
{
|
|
[MultiplayerOnly]
|
|
[Command("status")]
|
|
public static bool Status()
|
|
{
|
|
ServerManager.PrintDiagnostics();
|
|
return true;
|
|
}
|
|
|
|
[Command("connect")]
|
|
public static bool Connect(Dictionary<string, object> args)
|
|
{
|
|
try
|
|
{
|
|
string ip = (args.ContainsKey("addr") == true) ? args["addr"] as string : "michaeltheshifter.me";
|
|
int port = (args.ContainsKey("port") == true) ? Convert.ToInt32(args["port"] as string) : 13370;
|
|
try
|
|
{
|
|
ServerManager.Initiate(ip, port);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("{ERROR}: " + ex.Message);
|
|
}
|
|
|
|
TerminalBackend.PrefixEnabled = false;
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error running script:" + ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[Command("reconnect")]
|
|
[RequiresUpgrade("hacker101_deadaccts")]
|
|
public static bool Reconnect()
|
|
{
|
|
Console.WriteLine("--reconnecting to multi-user domain...");
|
|
KernelWatchdog.MudConnected = true;
|
|
Console.WriteLine("--done.");
|
|
return true;
|
|
}
|
|
|
|
[MultiplayerOnly]
|
|
[Command("disconnect")]
|
|
[RequiresUpgrade("hacker101_deadaccts")]
|
|
public static bool Disconnect()
|
|
{
|
|
Console.WriteLine("--connection to multi-user domain severed...");
|
|
KernelWatchdog.MudConnected = false;
|
|
return true;
|
|
}
|
|
|
|
[MultiplayerOnly]
|
|
[Command("sendmsg")]
|
|
[KernelMode]
|
|
[RequiresUpgrade("hacker101_deadaccts")]
|
|
[RequiresArgument("header")]
|
|
[RequiresArgument("body")]
|
|
public static bool SendMessage(Dictionary<string, object> args)
|
|
{
|
|
ServerManager.SendMessage(args["header"].ToString(), args["body"].ToString());
|
|
return true;
|
|
}
|
|
}
|
|
|
|
[TutorialLock]
|
|
[Namespace("trm")]
|
|
public static class TerminalCommands
|
|
{
|
|
[Command("clear")]
|
|
public static bool Clear()
|
|
{
|
|
AppearanceManager.ConsoleOut.Clear();
|
|
return true;
|
|
}
|
|
|
|
[Command("echo")]
|
|
[RequiresArgument("text")]
|
|
public static bool Echo(Dictionary<string, object> args)
|
|
{
|
|
Console.WriteLine(args["text"]);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
#if DEVEL
|
|
internal class Rock : Exception
|
|
{
|
|
internal Rock() : base("Someone threw a rock at the window, and the Terminal shattered.")
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[MultiplayerOnly]
|
|
[Namespace("dev")]
|
|
public static class ShiftOSDevCommands
|
|
{
|
|
[Command("buy")]
|
|
public static bool UnlockUpgrade(Dictionary<string, object> args)
|
|
{
|
|
string upg = args["id"].ToString();
|
|
try
|
|
{
|
|
SaveSystem.CurrentSave.Upgrades[upg] = true;
|
|
Shiftorium.InvokeUpgradeInstalled();
|
|
SaveSystem.SaveGame();
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Upgrade not found.");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[Command("rock", description = "A little surprise for unstable builds...")]
|
|
public static bool ThrowASandwichingRock()
|
|
{
|
|
Infobox.Show("He who lives in a glass house shouldn't throw stones...", new Rock().Message);
|
|
return false;
|
|
}
|
|
|
|
|
|
[Command("unbuy")]
|
|
[RequiresArgument("upgrade")]
|
|
public static bool UnbuyUpgrade(Dictionary<string, object> args)
|
|
{
|
|
try
|
|
{
|
|
SaveSystem.CurrentSave.Upgrades[args["upgrade"].ToString()] = false;
|
|
SaveSystem.SaveGame();
|
|
Desktop.PopulateAppLauncher();
|
|
Desktop.CurrentDesktop.SetupDesktop();
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Upgrade not found.");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[Command("getallupgrades")]
|
|
public static bool GetAllUpgrades()
|
|
{
|
|
Console.WriteLine(JsonConvert.SerializeObject(SaveSystem.CurrentSave.Upgrades, Formatting.Indented));
|
|
return true;
|
|
}
|
|
|
|
[Command("multarg")]
|
|
[RequiresArgument("id")]
|
|
[RequiresArgument("name")]
|
|
[RequiresArgument("type")]
|
|
public static bool MultArg(Dictionary<string, object> args)
|
|
{
|
|
Console.WriteLine("Success! "+args.ToString());
|
|
return true;
|
|
}
|
|
|
|
[Command("restart")]
|
|
public static bool Restart()
|
|
{
|
|
SaveSystem.CurrentSave.Upgrades = new Dictionary<string, bool>();
|
|
SaveSystem.CurrentSave.Codepoints = 0;
|
|
SaveSystem.CurrentSave.StoriesExperienced.Clear();
|
|
SaveSystem.CurrentSave.StoriesExperienced.Add("mud_fundamentals");
|
|
SaveSystem.SaveGame();
|
|
Shiftorium.InvokeUpgradeInstalled();
|
|
return true;
|
|
}
|
|
|
|
[Command("freecp")]
|
|
public static bool FreeCodepoints(Dictionary<string, object> args)
|
|
{
|
|
if (args.ContainsKey("amount"))
|
|
try
|
|
{
|
|
ulong codepointsToAdd = Convert.ToUInt64(args["amount"].ToString());
|
|
SaveSystem.CurrentSave.Codepoints += codepointsToAdd;
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("{ERROR}: " + ex.Message);
|
|
return true;
|
|
}
|
|
|
|
SaveSystem.CurrentSave.Codepoints += 1000;
|
|
return true;
|
|
}
|
|
|
|
[Command("unlockeverything")]
|
|
public static bool UnlockAllUpgrades()
|
|
{
|
|
foreach (var upg in Shiftorium.GetDefaults())
|
|
{
|
|
if (!SaveSystem.CurrentSave.Upgrades.ContainsKey(upg.ID))
|
|
SaveSystem.CurrentSave.Upgrades.Add(upg.ID, true);
|
|
else
|
|
SaveSystem.CurrentSave.Upgrades[upg.ID] = true;
|
|
}
|
|
Shiftorium.InvokeUpgradeInstalled();
|
|
SkinEngine.LoadSkin();
|
|
return true;
|
|
}
|
|
|
|
[Command("info")]
|
|
public static bool DevInformation()
|
|
{
|
|
Console.WriteLine("{SHIFTOS_PLUS_MOTTO}");
|
|
Console.WriteLine("{SHIFTOS_VERSION_INFO}" + Assembly.GetExecutingAssembly().GetName().Version);
|
|
return true;
|
|
}
|
|
[Command("pullfile")]
|
|
public static bool PullFile(Dictionary<string, object> args)
|
|
{
|
|
if (args.ContainsKey("physical") && args.ContainsKey("virtual"))
|
|
{
|
|
string file = (string)args["physical"];
|
|
string dest = (string)args["virtual"];
|
|
if (System.IO.File.Exists(file))
|
|
{
|
|
Console.WriteLine("Pulling physical file to virtual drive...");
|
|
byte[] filebytes = System.IO.File.ReadAllBytes(file);
|
|
ShiftOS.Objects.ShiftFS.Utils.WriteAllBytes(dest, filebytes);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("The specified file does not exist on the physical drive.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("You must supply a physical path.");
|
|
}
|
|
return true;
|
|
}
|
|
[Command("crash")]
|
|
public static bool CrashInstantly()
|
|
{
|
|
CrashHandler.Start(new Exception("ShiftOS was sent a command to forcefully crash."));
|
|
return true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[Namespace("sos")]
|
|
public static class ShiftOSCommands
|
|
{
|
|
|
|
[Command("setsfxenabled", description = "Set whether or not sound effects are enabled in the system.")]
|
|
[RequiresArgument("value")]
|
|
public static bool SetSfxEnabled(Dictionary<string, object> args)
|
|
{
|
|
try
|
|
{
|
|
bool value = Convert.ToBoolean(args["value"].ToString());
|
|
SaveSystem.CurrentSave.SoundEnabled = value;
|
|
SaveSystem.SaveGame();
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Error: Value must be either true or false.");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
[Command("setmusicenabled", description = "Set whether or not music is enabled in the system.")]
|
|
[RequiresArgument("value")]
|
|
public static bool SetMusicEnabled(Dictionary<string, object> args)
|
|
{
|
|
try
|
|
{
|
|
bool value = Convert.ToBoolean(args["value"].ToString());
|
|
SaveSystem.CurrentSave.MusicEnabled = value;
|
|
SaveSystem.SaveGame();
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("Error: Value must be either true or false.");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
[Command("setsfxvolume", description ="Set the system sound volume to a value between 1 and 100.")]
|
|
[RequiresArgument("value")]
|
|
public static bool SetSfxVolume(Dictionary<string, object> args)
|
|
{
|
|
int value = int.Parse(args["value"].ToString());
|
|
if(value >= 0 && value <= 100)
|
|
{
|
|
SaveSystem.CurrentSave.MusicVolume = value;
|
|
SaveSystem.SaveGame();
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Volume must be between 0 and 100!");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[RemoteLock]
|
|
[Command("shutdown")]
|
|
public static bool Shutdown()
|
|
{
|
|
TerminalBackend.InvokeCommand("sos.save");
|
|
AppearanceManager.Exit();
|
|
return true;
|
|
}
|
|
|
|
[Command("lang", "{COMMAND_SOS_LANG_USAGE}", "{COMMAND_SOS_LANG_DESCRIPTION}")]
|
|
[RequiresArgument("language")]
|
|
public static bool SetLanguage(Dictionary<string, object> userArgs)
|
|
{
|
|
try
|
|
{
|
|
string lang = "";
|
|
|
|
if (userArgs.ContainsKey("language"))
|
|
lang = (string)userArgs["language"];
|
|
else
|
|
throw new Exception("You must specify a valid 'language' value.");
|
|
|
|
if (Localization.GetAllLanguages().Contains(lang))
|
|
{
|
|
SaveSystem.CurrentSave.Language = lang;
|
|
SaveSystem.SaveGame();
|
|
Console.WriteLine("{LANGUAGE_CHANGED}");
|
|
return true;
|
|
}
|
|
|
|
throw new Exception($"Couldn't find language with ID: {lang}");
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[Command("help", "{COMMAND_HELP_USAGE", "{COMMAND_HELP_DESCRIPTION}")]
|
|
public static bool Help(Dictionary<string, object> args)
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.AppendLine("Retrieving help data.");
|
|
|
|
if (args.ContainsKey("ns"))
|
|
{
|
|
string ns = args["ns"].ToString();
|
|
//First let's check for a command that has this namespace.
|
|
var cmdtest = TerminalBackend.Commands.FirstOrDefault(x => x.NamespaceInfo.name == ns);
|
|
if (cmdtest == null) //Namespace not found.
|
|
sb.AppendLine("Error retrieving help for namespace \"" + ns + "\". Namespace not found.");
|
|
else
|
|
{
|
|
//Now do the actual scan.
|
|
sb.AppendLine("Namespace: " + ns);
|
|
foreach(var cmd in TerminalBackend.Commands.Where(x => x.NamespaceInfo.name == ns))
|
|
{
|
|
string str = cmd.ToString();
|
|
str = str.Replace(str.Substring(str.LastIndexOf("|")), "");
|
|
sb.AppendLine(str);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
//print all unique namespaces.
|
|
foreach(var n in TerminalBackend.Commands.Select(x => x.NamespaceInfo.name).Distinct())
|
|
{
|
|
sb.AppendLine("sos.help{ns:\"" + n + "\"}");
|
|
}
|
|
}
|
|
|
|
Console.WriteLine(sb.ToString());
|
|
|
|
return true;
|
|
}
|
|
|
|
[MultiplayerOnly]
|
|
[Command("save")]
|
|
public static bool Save()
|
|
{
|
|
SaveSystem.SaveGame();
|
|
return true;
|
|
}
|
|
|
|
[MultiplayerOnly]
|
|
[Command("status")]
|
|
public static bool Status()
|
|
{
|
|
string status = $@"ShiftOS version {Assembly.GetExecutingAssembly().GetName().Version.ToString()}
|
|
|
|
Codepoints: {SaveSystem.CurrentSave.Codepoints}
|
|
Upgrades: {SaveSystem.CurrentSave.CountUpgrades()} installed,
|
|
{Shiftorium.GetAvailable().Length} available
|
|
|
|
";
|
|
|
|
Console.WriteLine(status);
|
|
Console.WriteLine("Objectives:");
|
|
try
|
|
{
|
|
if (Story.CurrentObjectives.Count > 0)
|
|
{
|
|
foreach (var obj in Story.CurrentObjectives)
|
|
{
|
|
Console.WriteLine(obj.Name);
|
|
Console.WriteLine("-------------------------------");
|
|
Console.WriteLine();
|
|
Console.WriteLine(obj.Description);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine(" - No objectives are running. Check back later!");
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine(" - No objectives are running. Check back later!");
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
[MultiplayerOnly]
|
|
[Namespace("shiftorium")]
|
|
public static class ShiftoriumCommands
|
|
{
|
|
[Command("buy")]
|
|
[RequiresArgument("upgrade")]
|
|
public static bool BuyUpgrade(Dictionary<string, object> userArgs)
|
|
{
|
|
try
|
|
{
|
|
string upgrade = "";
|
|
|
|
if (userArgs.ContainsKey("upgrade"))
|
|
upgrade = (string)userArgs["upgrade"];
|
|
else
|
|
throw new Exception("You must specify a valid 'upgrade' value.");
|
|
|
|
foreach (var upg in Shiftorium.GetAvailable())
|
|
{
|
|
if (upg.ID == upgrade)
|
|
{
|
|
Shiftorium.Buy(upgrade, upg.Cost);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
throw new Exception($"Couldn't find upgrade with ID: {upgrade}");
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[RequiresUpgrade("shiftorium_bulk_buy")]
|
|
[Command("bulkbuy")]
|
|
[RequiresArgument("upgrades")]
|
|
public static bool BuyBulk(Dictionary<string, object> args)
|
|
{
|
|
if (args.ContainsKey("upgrades"))
|
|
{
|
|
string[] upgrade_list = (args["upgrades"] as string).Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
|
|
foreach (var upg in upgrade_list)
|
|
{
|
|
var dict = new Dictionary<string, object>();
|
|
dict.Add("upgrade", upg);
|
|
BuyUpgrade(dict);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("Please specify a list of upgrades in the 'upgrades' argument. Each upgrade is separated by a comma.");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
[Command("info")]
|
|
public static bool ViewInfo(Dictionary<string, object> userArgs)
|
|
{
|
|
try
|
|
{
|
|
string upgrade = "";
|
|
|
|
if (userArgs.ContainsKey("upgrade"))
|
|
upgrade = (string)userArgs["upgrade"];
|
|
else
|
|
throw new Exception("You must specify a valid 'upgrade' value.");
|
|
|
|
foreach (var upg in Shiftorium.GetDefaults())
|
|
{
|
|
if (upg.ID == upgrade)
|
|
{
|
|
Console.WriteLine($@"Information for {upgrade}:
|
|
|
|
{upg.Category}: {upg.Name} - {upg.Cost} Codepoints
|
|
------------------------------------------------------
|
|
|
|
{upg.Description}
|
|
|
|
To buy this upgrade, run:
|
|
shiftorium.buy{{upgrade:""{upg.ID}""}}");
|
|
return true;
|
|
}
|
|
}
|
|
|
|
throw new Exception($"Couldn't find upgrade with ID: {upgrade}");
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[Command("categories")]
|
|
public static bool ListCategories()
|
|
{
|
|
foreach(var cat in Shiftorium.GetCategories())
|
|
{
|
|
Console.WriteLine($"{cat} - {Shiftorium.GetAvailable().Where(x=>x.Category==cat).Count()} upgrades");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[Command("list")]
|
|
public static bool ListAll(Dictionary<string, object> args)
|
|
{
|
|
try
|
|
{
|
|
bool showOnlyInCategory = false;
|
|
|
|
string cat = "Other";
|
|
|
|
if (args.ContainsKey("cat"))
|
|
{
|
|
showOnlyInCategory = true;
|
|
cat = args["cat"].ToString();
|
|
}
|
|
|
|
Dictionary<string, ulong> upgrades = new Dictionary<string, ulong>();
|
|
int maxLength = 5;
|
|
|
|
IEnumerable<ShiftoriumUpgrade> upglist = Shiftorium.GetAvailable();
|
|
if (showOnlyInCategory)
|
|
{
|
|
if (Shiftorium.IsCategoryEmptied(cat))
|
|
{
|
|
ConsoleEx.Bold = true;
|
|
ConsoleEx.ForegroundColor = ConsoleColor.Red;
|
|
Console.WriteLine("Shiftorium Query Error");
|
|
Console.WriteLine();
|
|
ConsoleEx.Bold = false;
|
|
ConsoleEx.ForegroundColor = ConsoleColor.Gray;
|
|
Console.WriteLine("Either there are no upgrades in the category \"" + cat + "\" or the category was not found.");
|
|
return true;
|
|
}
|
|
upglist = Shiftorium.GetAvailable().Where(x => x.Category == cat);
|
|
}
|
|
|
|
|
|
if(upglist.Count() == 0)
|
|
{
|
|
ConsoleEx.Bold = true;
|
|
ConsoleEx.ForegroundColor = ConsoleColor.Red;
|
|
Console.WriteLine("No upgrades available!");
|
|
Console.WriteLine();
|
|
ConsoleEx.Bold = false;
|
|
ConsoleEx.ForegroundColor = ConsoleColor.Gray;
|
|
Console.WriteLine("You have installed all available upgrades for your system. Please check back later for more.");
|
|
return true;
|
|
|
|
}
|
|
foreach (var upg in upglist)
|
|
{
|
|
if (upg.ID.Length > maxLength)
|
|
{
|
|
maxLength = upg.ID.Length;
|
|
}
|
|
|
|
upgrades.Add(upg.ID, upg.Cost);
|
|
}
|
|
|
|
Console.WriteLine("ID".PadRight((maxLength + 5) - 2) + "Cost (Codepoints)");
|
|
|
|
foreach (var upg in upgrades)
|
|
{
|
|
Console.WriteLine(upg.Key.PadRight((maxLength + 5) - upg.Key.Length) + " " + upg.Value.ToString());
|
|
}
|
|
return true;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
CrashHandler.Start(e);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Namespace("win")]
|
|
public static class WindowCommands
|
|
{
|
|
|
|
|
|
|
|
[RemoteLock]
|
|
[Command("list")]
|
|
public static bool List()
|
|
{
|
|
Console.WriteLine("Window ID\tName");
|
|
foreach (var app in AppearanceManager.OpenForms)
|
|
{
|
|
//Windows are displayed the order in which they were opened.
|
|
Console.WriteLine($"{AppearanceManager.OpenForms.IndexOf(app)}\t{app.Text}");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
[RemoteLock]
|
|
[Command("open")]
|
|
public static bool Open(Dictionary<string, object> args)
|
|
{
|
|
try
|
|
{
|
|
if (args.ContainsKey("app"))
|
|
{
|
|
var app = args["app"] as string;
|
|
//ANNND now we start reflecting...
|
|
foreach (var type in Array.FindAll(ReflectMan.Types, t => t.BaseType == typeof(UserControl)))
|
|
{
|
|
var attr = type.GetCustomAttributes(false).FirstOrDefault(a => a is WinOpenAttribute && app == (a as WinOpenAttribute).ID);
|
|
if (attr != null)
|
|
{
|
|
if (SaveSystem.CurrentSave.Upgrades.ContainsKey(app))
|
|
{
|
|
if (Shiftorium.UpgradeInstalled(app))
|
|
{
|
|
IShiftOSWindow frm = Activator.CreateInstance(type) as IShiftOSWindow;
|
|
AppearanceManager.SetupWindow(frm);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
throw new Exception($"{app} was not found on your system! Try looking in the shiftorium...");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IShiftOSWindow frm = Activator.CreateInstance(type) as IShiftOSWindow;
|
|
AppearanceManager.SetupWindow(frm);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
foreach (var type in Array.FindAll(ReflectMan.Types, t => t.GetInterfaces().Contains(typeof(IShiftOSWindow)) && Shiftorium.UpgradeAttributesUnlocked(t)))
|
|
foreach (var attr in Array.FindAll(type.GetCustomAttributes(false), a => a is WinOpenAttribute))
|
|
Console.WriteLine("win.open{app:\"" + (attr as WinOpenAttribute).ID + "\"}");
|
|
|
|
|
|
return true;
|
|
}
|
|
Console.WriteLine("Couldn't find the specified app on your system.");
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error running script:" + ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[RemoteLock]
|
|
[Command("close", usage = "{win:integer32}", description ="Closes the specified window.")]
|
|
[RequiresArgument("win")]
|
|
[RequiresUpgrade("close_command")]
|
|
public static bool CloseWindow(Dictionary<string, object> args)
|
|
{
|
|
int winNum = -1;
|
|
if (args.ContainsKey("win"))
|
|
winNum = Convert.ToInt32(args["win"].ToString());
|
|
string err = null;
|
|
|
|
if (winNum < 0 || winNum >= AppearanceManager.OpenForms.Count)
|
|
err = "The window number must be between 0 and " + (AppearanceManager.OpenForms.Count - 1).ToString() + ".";
|
|
|
|
if (string.IsNullOrEmpty(err))
|
|
{
|
|
Console.WriteLine($"Closing {AppearanceManager.OpenForms[winNum].Text}...");
|
|
AppearanceManager.Close(AppearanceManager.OpenForms[winNum].ParentWindow);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine(err);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
}
|
|
}
|