Exemplo n.º 1
0
        public void AttachTickHandlers(object instance)
        {
            TickHandlers.TryGetValue(instance.GetType(), out var methods);

            methods?.ForEach(async self =>
            {
                var handler = (TickHandler)self.GetCustomAttribute(typeof(TickHandler));

                if (handler.SessionWait)
                {
                    await Session.Loading();
                }

                Tick += (Func <Task>)Delegate.CreateDelegate(typeof(Func <Task>), instance, self);

                RegisteredTickHandlers.Add(instance.GetType());
            });
        }
Exemplo n.º 2
0
        public async Task Load()
        {
            DiscordRichPresence.Commit();

            Logger.Info("[Managers] Loading in all managers, one moment please...");

            Assembly.GetExecutingAssembly().GetExportedTypes()
            .SelectMany(self => self.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance))
            .Where(self => self.GetCustomAttribute(typeof(TickHandler), false) != null).ToList()
            .ForEach(self =>
            {
                var type = self.DeclaringType;

                if (type == null)
                {
                    return;
                }

                if (!TickHandlers.ContainsKey(type))
                {
                    TickHandlers.Add(type, new List <MethodInfo>());
                }

                Logger.Debug($"[TickHandlers] {type.Name}::{self.Name}");

                TickHandlers[type].Add(self);
            });

            var loaded = 0;

            // Load event system first
            LoadManager(typeof(EventSystem));

            foreach (var type in Assembly.GetExecutingAssembly().GetExportedTypes())
            {
                if (type.BaseType == null)
                {
                    continue;
                }
                if (!type.BaseType.IsGenericType)
                {
                    continue;
                }

                var generic = type.BaseType.GetGenericTypeDefinition();

                if (generic != typeof(Manager <>) || type == typeof(Manager <>))
                {
                    continue;
                }

                LoadManager(type);

                loaded++;
            }

            foreach (var manager in Managers)
            {
                var method = manager.Key.GetMethod("Begin", BindingFlags.Public | BindingFlags.Instance);

                method?.Invoke(manager.Value, null);
            }

            Logger.Info($"[Managers] Successfully loaded in {loaded} manager(s)!");

            var commands = new CommandFramework();

            commands.Bind(typeof(Administrator));
            commands.Bind(typeof(DeveloperTools));
            commands.Bind(typeof(StatusCommands.Online));
            commands.Bind(typeof(RoleplayChat.Me));
            commands.Bind(typeof(RoleplayChat.Twitter));
            commands.Bind(typeof(UtilityTools.Reload));
            commands.Bind(typeof(UtilityTools.Report));

            API.SetMaxWantedLevel(0);

            AttachTickHandlers(this);

            Logger.Info("Load method has been completed.");
        }