예제 #1
0
 private static IEnumerable <IngotType> PrepareIngotTypes(RequestedConfiguration configuration, Blueprints blueprints)
 {
     return(Constants.INGOT_TYPES
            .Select(new IngotConfigurer(configuration.Ingots).Configure)
            .Where(i => i.Enabled)
            .Select(blueprints.CalculateNormalisationFactor));
 }
예제 #2
0
        public Program()
        {
            Debug.Initialise(Debug.Level.Info, Echo);

            configuration = new ConfigurationReader().Deserialise(RequestedConfiguration.GetDefault(), Storage);

            Runtime.UpdateFrequency = UpdateFrequency.Update10 | UpdateFrequency.Update100;
        }
예제 #3
0
        public Program()
        {
            Debug.Initialise(Debug.Level.Info, Echo);
            ResourceMonitorDriver.StaticInitialise();

            configuration = new ConfigurationReader().Deserialise(RequestedConfiguration.GetDefault(), Storage);

            Runtime.UpdateFrequency = Constants.EXPECTED_UPDATE_MODE;
        }
예제 #4
0
        public StaticState(RequestedConfiguration configuration)
        {
            Blueprints      = new Blueprints(Constants.BLUEPRINTS);
            RefineryFactory = new RefineryFactory(Constants.REFINERY_TYPES);

            var ores = Constants.BLUEPRINTS.Select(b => b.Input.ItemType).Distinct();

            OreTypes = new OreTypes(ores, Constants.BLUEPRINTS);

            var ingotTypes = PrepareIngotTypes(configuration, Blueprints).ToArray();

            IngotTypes = new IngotTypes(ingotTypes);

            RefinerySpeedFactor    = configuration.RefinerySpeedFactor;
            AssemblerSpeedFactor   = configuration.AssemblerSpeedFactor;
            IngotStatusDisplayName = configuration.IngotStatusDisplayName;
            OreStatusDisplayName   = configuration.OreStatusDisplayName;
            InventoryBlockNames    = configuration.InventoryBlockNames;
        }
예제 #5
0
        public void Main(string argument, UpdateType updateSource)
        {
            Clock.AddTime(Runtime.TimeSinceLastRun);

            if (current == null)
            {
                Debug.ClearBuffer();
            }
            else
            {
                Debug.RestoreBuffer();
            }

            if (commandLine.TryParse(argument))
            {
                var command = commandLine.Argument(0);
                switch (command?.ToLower())
                {
                case "configure":
                    configuration = new ConfigurationReader().UpdateFromCommandLine(configuration, commandLine.Items.Skip(1));
                    instance      = null;
                    break;

                case "reset":
                    configuration = new RequestedConfiguration();
                    instance      = null;
                    break;

                case "rescan":
                    Rescan();
                    break;
                }
            }

            EnsureInitialised();

            if ((updateSource & (UpdateType.Update1 | UpdateType.Update10 | UpdateType.Update100)) != 0)
            {
                HandlePeriodicUpdate();
            }
        }
 public ResourceMonitorDriver(RequestedConfiguration configuration)
 {
     this.configuration = configuration;
     blockRuleFilter    = new BlockFilterFactory().CreateRuleFilter(configuration.BlockRules);
 }
예제 #7
0
        public void Main(string argument, UpdateType updateSource)
        {
            Clock.AddTime(Runtime.TimeSinceLastRun);

            EnsureInitialised();

            if (commandLine.TryParse(argument))
            {
                var command = commandLine.Argument(0);
                switch (command?.ToLower())
                {
                case "test":
                    configuration.TestedHash = state.GetCurrentHash();
                    state.BowEngines.BeginTest();
                    state.MidshipsEngines.BeginTest();
                    commandState = "Running test pattern.";
                    break;

                case "set":
                    var tier   = commandLine.Argument(1);
                    var preset = commandLine.Argument(2) ?? "";
                    switch (tier.ToLower())
                    {
                    case "bow":
                        if (state.BowEngines.ActivatePreset(preset) == false)
                        {
                            commandErrors.Warnings.Add(new Message("Bow engine preset not recognised: {0}", preset));
                        }
                        else
                        {
                            commandState = new Message("Move Bow engine to preset: {0}", preset);
                        }
                        break;

                    case "midships":
                        if (state.MidshipsEngines.ActivatePreset(preset) == false)
                        {
                            commandErrors.Warnings.Add(new Message("Midships engine preset not recognised: {0}", preset));
                        }
                        else
                        {
                            commandState = new Message("Move Midships engine to preset: {0}", preset);
                        }
                        break;
                    }
                    break;


                case "stop":
                    state.BowEngines.Stop();
                    state.MidshipsEngines.Stop();
                    commandState = "Stopped.";
                    break;

                case "rescan":
                    renderer.Rescan(GridTerminalSystem);
                    state.PendingRescan = true;
                    break;

                case "reset":
                    state.BowEngines.Stop();
                    state.MidshipsEngines.Stop();
                    configuration = RequestedConfiguration.GetDefault();
                    state         = null;
                    return;
                }
            }

            stateErrors.Clear();
            if (state.GetCurrentHash() != configuration.TestedHash)
            {
                stateErrors.SafetyConcerns.Add("Configuration has changed since the last test.");
            }
            state.BowEngines.CheckState(stateErrors);
            state.MidshipsEngines.CheckState(stateErrors);

            HandlePeriodicUpdate();

            renderer.Render(stateErrors, commandErrors, commandState);
        }