public void GetImplementationOrAbstractionFixture()
{
var list = ReflectiveEnumerator.GetInheritedFromAbstractClass <Functionality>();
FileOperations.AppendLine("testing.log", JsonToFrom.Serialize(list));
Assert.True(list.Count > 0);
}
/// <summary>
/// Caches the character races
/// </summary>
private static void CacheRaces()
{
if (_cachedRaces == null || _cachedRaces.Count == 0)
{
_cachedRaces = ReflectiveEnumerator.GetEnumerableOfType <RaceBase>().ToList();
}
}
static void Main(string[] args)
{
Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.WriteLine("Hello World!");
var token = File.ReadAllText(AppContext.BaseDirectory + "token").Trim();
Handlers = new List <BaseHandler>()
{
new ConsoleWriterHandler()
}
.Concat(ReflectiveEnumerator.GetListOfType <BaseHandler>().Where(a => !(a is ConsoleWriterHandler)))
.ToList();
for (int i = 0; i < Handlers.Count - 1; i++)
{
Handlers[i].NextHandler = Handlers[i + 1];
}
_client = new TelegramBotClient(token);
_client.OnMessage += OnMessage;
_client.OnMessageEdited += OnMessage;
AppDomain.CurrentDomain.UnhandledException += async(object sender, UnhandledExceptionEventArgs args2) =>
{
await _client.SendTextMessageAsync(new ChatId(91740825), $"Unhandled exception!\n{args2.ExceptionObject}\n{(args2.ExceptionObject as Exception).InnerException?.Message}", disableNotification : true);
};
_client.StartReceiving(new[] { UpdateType.EditedMessage, UpdateType.Message });
Console.ReadLine();
}
public CommandFactory()
{
Commands = new List <Command>();
// Check to see if plugins folder exists, then try loading
if (Directory.Exists($"{AppDomain.CurrentDomain.BaseDirectory}plugins"))
{
ConsoleHelper.WriteLine("Plugins folder found, attempting to load...");
var directoryInfo = new DirectoryInfo($"{AppDomain.CurrentDomain.BaseDirectory}plugins");
int pluginCount = 0;
foreach (var plugin in directoryInfo.GetFiles("*.dll"))
{
var DLL = Assembly.LoadFile(plugin.FullName);
foreach (Type type in DLL.GetExportedTypes().Where(x => typeof(Command).IsAssignableFrom(x)))
{
var c = Activator.CreateInstance(type) as Command;
Commands.Add(c);
}
pluginCount++;
}
ConsoleHelper.WriteLine($"Added {pluginCount} plugin(s).");
}
var commandsEnum = ReflectiveEnumerator.GetEnumerableOfType <Command>();
foreach (Command c in commandsEnum)
{
Commands.Add(c);
}
ConsoleHelper.WriteLine($"Added {Commands.Count} command(s).");
}
/// <summary>
/// Caches the languages
/// </summary>
private static void CacheLanguages()
{
if (_cachedLanguages == null || _cachedLanguages.Count == 0)
{
_cachedLanguages = ReflectiveEnumerator.GetEnumerableOfType <Language>().ToList();
}
}
public async Task MainAsync()
{
//idk
commands = new Dictionary <string, Command>();
var eee = ReflectiveEnumerator.GetEnumerableOfType <Command>();
foreach (var command in eee)
{
commands.Add(command.commandname, command);
}
if (File.Exists(@"test.bin"))
{
Stream stream = new FileStream(@"test.bin", FileMode.Open, FileAccess.Read);
IFormatter formatter = new BinaryFormatter();
#pragma warning disable SYSLIB0011 // Type or member is obsolete
db = (DiscordDatabase)formatter.Deserialize(stream); //get f****d ms
#pragma warning restore SYSLIB0011 // Type or member is obsolete
}
else
{
db = new DiscordDatabase();
db.Servers = new Dictionary <ulong, DiscordServer>();
}
_client = new DiscordSocketClient();
_client.Log += Log;
_client.MessageReceived += MessageReceivedAsync;
String tok = File.ReadAllText("Token.txt");
await _client.LoginAsync(TokenType.Bot, tok);
await _client.StartAsync();
// Block this task until the program is closed.
await Task.Delay(-1);
}
public async Task GetChancesAsync(CommandContext ctx)
{
List <WheelOutcome> wheelOutcomes = ReflectiveEnumerator.GetEnumerableOfType <WheelOutcome>(SlaveReportsExtension.Outcome.Task)
.ToList();
DiscordEmbedBuilder builder = new DiscordEmbedBuilder();
builder.WithDescription(
"I've compiled the current List of Chances. First, you'll see a List of Modules (Sabrina.Entities.WheelOutcomes.XXX).\n"
+ "Under the Module Titles for each of these, is a freshly generated example, under that, you'll see the Chance for this to be chosen.\n"
+ "The Bot will add all Chance Values, and then generate a Random Number, to determine which Module will be chosen.\n\n"
+ string.Empty
+ "Under that, you'll see the Chances for what the chosen Module will output at the end.\n"
+ "If the Module does not have a fitting response (Ban can never end in an o****m for example), it will be ignored.");
foreach (var wheelOutcome in wheelOutcomes)
{
builder.AddField(
wheelOutcome.ToString(),
"``" + wheelOutcome.Text + "``\n" + wheelOutcome.Chance);
}
// builder.AddField("Task", OrgasmWheel.TaskChance.ToString(), true);
// builder.AddField("Denial", OrgasmWheel.DenialChance.ToString(), true);
// builder.AddField("Ruin", OrgasmWheel.RuinChance.ToString(), true);
// builder.AddField("O****m", OrgasmWheel.OrgasmChance.ToString(), true);
await ctx.RespondAsync(embed : builder.Build());
}
/// <summary>
/// Caches the character attributes
/// </summary>
private static void CacheAttributes()
{
if (_cachedAttributes == null || _cachedAttributes.Count == 0)
{
_cachedAttributes = ReflectiveEnumerator.GetEnumerableOfType <AttributeBase>(0).ToList();
}
}
static AbstractItemAspect()
{
var aspects = ReflectiveEnumerator.GetEnumerableOfType <AbstractItemAspect>().ToList();
foreach (var item in aspects)
{
AvailableAspects.Add(item);
}
}
public TaskEditor()
{
types = ReflectiveEnumerator.DerivedTypes <Task>().ToArray();
typenames = new string[types.Length];
for (int i = 0; i < types.Length; ++i)
{
typenames[i] = types[i].ToString();//.Split('.').Last();
}
}
public static IEnumerable <IArmouryProtocolKB> Find()
{
foreach (IArmouryProtocolKB currentKBInstance in ReflectiveEnumerator.GetEnumerableOfType <IArmouryProtocolKB>())
{
if (currentKBInstance.DoesExistOnSystem())
{
yield return(currentKBInstance);
}
}
}
public static void InitMapping()
{
Mapper.Initialize(x =>
{
foreach (var profile in ReflectiveEnumerator.GetInstanceOfSubclasses <Profile>(true))
{
x.AddProfile(profile);
}
});
}
private void comboBox_paymentScheme_Loaded(object sender, RoutedEventArgs e)
{
var paybackSchemeList = ReflectiveEnumerator.GetChildOfType(typeof(PaybackScheme));
var combo = sender as ComboBox;
combo.ItemsSource = paybackSchemeList;
combo.DisplayMemberPath = "Name";
combo.SelectedValuePath = "AssemblyQualifiedName";
combo.SelectedIndex = 0;
}
public CommandFactory()
{
Commands = new List <Command>();
var commandsEnum = ReflectiveEnumerator.GetEnumerableOfType <Command>();
foreach (Command c in commandsEnum)
{
Commands.Add(c);
}
}
public SceneManager(Game gamee)
{
this.game = gamee;
IEnumerable <Scene> test = ReflectiveEnumerator.GetEnumerableOfType <Scene>();
foreach (Scene testt in test)
{
Console.WriteLine(testt.name);
}
scenes = test;
}
private async Task <WheelOutcome> GetWheelOutcome(DiscordContext context, Users user, UserSetting.Outcome outcome)
{
WheelOutcome wheelOutcome = null;
var userItems = await WheelItemExtension.GetUserItemsAsync(user.UserId, context);
while (wheelOutcome == null)
{
try
{
wheelOutcomes = ReflectiveEnumerator.GetEnumerableOfType <WheelOutcome>(outcome, UserSetting.GetAllSettings(user.UserId, context).ToDictionary(setting => (UserSetting.SettingID)setting.SettingId), userItems, _services)
.ToList();
}
catch (Exception e)
{
Console.WriteLine(e);
}
foreach (var wheeloutcome in wheelOutcomes)
{
await wheeloutcome.BuildAsync();
}
wheelOutcomes = wheelOutcomes.Where(e => !e.Outcome.HasFlag(UserSetting.Outcome.NotSet)).ToList();
if (wheelOutcomes.Count < 1)
{
continue;
}
// Choose an outcome by summing up the chance values of all possible outcomes and
// then generating a random number inside those.
var combinedChance = 0;
foreach (WheelOutcome currentOutcome in wheelOutcomes)
{
combinedChance += currentOutcome.Chance;
}
var chance = 0;
var minChance = Helpers.RandomGenerator.RandomInt(0, combinedChance);
foreach (WheelOutcome currentOutcome in wheelOutcomes)
{
chance += currentOutcome.Chance;
if (minChance < chance)
{
wheelOutcome = currentOutcome;
break;
}
}
}
return(wheelOutcome);
}
public static void Main()
{
var sabtReqID = 0;
var myCase = ReflectiveEnumerator.GetEnumerableOfType <Case>().FirstOrDefault(c => c.Id == sabtReqID);
if (myCase != null)
{
myCase.Todo();
}
}
public void ShouldReturnAllTypesWithIncjectedServices()
{
// arrange
var provider = new Mock <IServiceProvider>();
// act
var steps = ReflectiveEnumerator.GetEnumerableOfType <IPipelineStep>(provider.Object);
// assert
Assert.Equal(4, steps.Count());
}
public SceneManager(Game game)
{
this._game = game;
IEnumerable <Scene> scenes = ReflectiveEnumerator.GetEnumerableOfType <Scene>();
foreach (Scene testt in scenes)
{
Console.WriteLine(testt.name);
}
this._scenes = scenes;
}
void InitSkills()
{
List <Skill> skills = ReflectiveEnumerator.GetEnumerableOfType <Skill>().ToList();
RefreshSkillList(AllSkills, skills, s =>
{
InfoContainer.transform.Find("Name").GetComponent <Text>().text = "Name: " + s.Name;
InfoContainer.transform.Find("Target").GetComponent <Text>().text = "Targets: " + s.Mode;
InfoContainer.transform.Find("Cooldown").GetComponent <Text>().text = "Cooldown: " + s.MaxCooldown;
InfoContainer.transform.Find("Description").GetComponent <Text>().text = "Description: " + s.Description;
});
}
public static void Initialize()
{
var commandClasses = ReflectiveEnumerator.GetInheritedFromInterface <ICommand>();
foreach (var commandClass in commandClasses)
{
var commandAttribute = commandClass.GetType().GetCustomAttributes(typeof(Command), false).FirstOrDefault() as Command;
if (commandAttribute == null)
{
continue;
}
Get.Add(commandAttribute.CommandText, commandClass);
}
}
private static void CatalogAvailableComponents()
{
ComponentsByPackage = new Dictionary <string, List <Type> >();
ComponentsByQualifiedName = new Dictionary <string, Type>();
QualifedNameByComponentType = new Dictionary <Type, string>();
List <Type> packageList;
foreach (Type t in ReflectiveEnumerator.GetEnumerableOfType <NoFlo_Basic.Component>())
{
string name = t.GetAttributeValue((ComponentNameAttribute dna) => dna.name);
string package = t.GetAttributeValue((ComponentPackageAttribute dna) => dna.name);
string qualifiedName = package + "/" + name;
if (name == "")
{
throw new Exception("Component " + t.Name + " does not have valid attribute ComponentName");
}
if (package == "")
{
throw new Exception("Component " + t.Name + " does not have valid attribute ComponentPackage");
}
if (ComponentsByQualifiedName.ContainsKey(qualifiedName))
{
throw new Exception("TODO");
}
ComponentsByQualifiedName.Add(qualifiedName, t);
if (!ComponentsByPackage.TryGetValue(package, out packageList))
{
packageList = new List <Type>();
ComponentsByPackage.Add(package, packageList);
}
if (packageList.Contains(t))
{
throw new Exception("TODO");
}
packageList.Add(t);
QualifedNameByComponentType.Add(t, qualifiedName);
}
isInitialised = true;
}
private static async Task AsyncMain()
{
CancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = CancellationTokenSource.Token;
Console.CancelKeyPress += (x, y) =>
{
CancellationTokenSource.Cancel();
};
Discord = new DiscordClient(new DiscordConfiguration()
{
Token = BotDetails.Token,
TokenType = TokenType.Bot
});
await Discord.ConnectAsync();
Logger.Log("Discord Connected");
await Discord.UpdateStatusAsync(new DiscordGame(BotDetails.CommandPrefix + "doc"));
foreach (var functionality in ReflectiveEnumerator.GetInheritedFromAbstractClass <Functionality>())
{
functionality.Start(Discord);
}
CommandConfiguration.Initialize();
Discord.MessageCreated += async x =>
{
if (x.Message.Content.IndexOf(BotDetails.CommandPrefix) == 0)
{
string command = GetFirstWord(x.Message.Content);
if (!CommandConfiguration.Get.ContainsKey(command))
{
return;
}
string reply = string.Empty;
try
{
reply = await CommandConfiguration.Get[command].ProcessAsync(x.Message);
}
catch { }
Logger.Log($"<Message: {x.Message.Content}>\t<Author: {x.Author.Id}>\t<Name: {x.Author.Username}>\t<Reply: {reply}>");
await x.Message.RespondAsync(reply);
}
};
await Task.Delay(-1, cancellationToken);
}
public void preLoadAllCards()
{
IEnumerable <Card> allCards = ReflectiveEnumerator.GetEnumerableOfType <Card>();
foreach (Card card in allCards)
{
//card base classes with this class name are not real cards and should be ignored
if (card.GetType().Name.Contains("Base_"))
{
continue;
}
//this method will call this class to cash all resources the card requires to function
card.cacheResorces();
}
}
void OnEnable()
{
List <GameConfiguration> possibleconfig = ReflectiveEnumerator.GetEnumerableOfType <GameConfiguration>();
confignames = new List <string>();
foreach (GameConfiguration g in possibleconfig)
{
confignames.Add(g.GetType().ToString());
}
generateAtRuntime = serializedObject.FindProperty("generateAtRuntime");
configurationname = serializedObject.FindProperty("configurationname");
themepropertyname = serializedObject.FindProperty("ThemePropertyName");
hastheme = serializedObject.FindProperty("hastheme");
allowOnlyCompleteThemes = serializedObject.FindProperty("allowOnlyCompleteThemes");
}
public static bool InstanciateAllDerivedTypes()
{
//if (IsInitiated) return false;
//prevent duplicate parser
//InstanciatedParsers.Clear();
var list = ReflectiveEnumerator.GetEnumerableOfType <Scraper>();
InstanciatedScrapers = from scraper
in list
where scraper.Ignore == false
select scraper;
IsInitiated = true;
return(true);
}
private void Awake()
{
List <AbstractImageEffect> image_effects = ReflectiveEnumerator.GetEnumerableOfType <AbstractImageEffect>().ToList();
for (int i = 0; i < Enum.GetNames(typeof(AbstractImageEffect.ImageEffectEnum)).Length; i++)
{
images.Add((AbstractImageEffect.ImageEffectEnum)i, image_effects[i]);
}
List <AbstractTextEffect> text_effects = ReflectiveEnumerator.GetEnumerableOfType <AbstractTextEffect>().ToList();
for (int i = 0; i < Enum.GetNames(typeof(AbstractTextEffect.TextEffectEnum)).Length; i++)
{
text.Add((AbstractTextEffect.TextEffectEnum)i, text_effects[i]);
}
}
public static void ConfigureContainer()
{
var container = new ServiceContainer();
container.RegisterApiControllers();
container.EnablePerWebRequestScope();
container.EnableWebApi(GlobalConfiguration.Configuration);
var mi = ReflectiveEnumerator.GetGenericMethods <ServiceContainer>(nameof(ServiceContainer.Register))
.Where(x => x.GetParameters().Length == 0 && x.GetGenericArguments().Length == 1).ToList();
foreach (var type in ReflectiveEnumerator.GetClassesWithInterface <IDependency>(false))
{
mi.First().MakeGenericMethod(type).Invoke(container, null);
}
}
private void updatePosibleEffectsList()
{
IEnumerable <Effect> possibleEffectEnumerable = ReflectiveEnumerator.GetEnumerableOfType <Effect>(new object[0]);
int possibleEffectsCount = possibleEffectEnumerable.Count();
possibleEffectsListNames = new string[possibleEffectsCount];
possibleEffectsList = new EffectProperties[possibleEffectsCount];
int index = 0;
foreach (Effect effect in possibleEffectEnumerable)
{
EffectProperties properties = effect.getEffectPropertiesStructure(false);
possibleEffectsListNames[index] = properties.effectClassName;
possibleEffectsList[index++] = properties;
}
}
public MainForm()
{
InitializeComponent();
var heuristics = ReflectiveEnumerator.GetOfType <Heuristic>();
foreach (var heuristic in heuristics)
{
ComboHeuristic.Items.Add(heuristic);
}
ComboHeuristic.SelectedIndex = 0;
ListNextStep.DataSource = null;
ListNextStep.DataSource = StepInfo.GetSteps();
_semaphore = new Semaphore(0, 1, "Steps");
}
