Example #1
0
            public Vector2 Draw(Drawing drawing, Vector2 position)
            {
                if (!enable)
                {
                    return(position);
                }
                List <string> types = new List <string>();

                if (tank_h2)
                {
                    types.Add("Hydrogen");
                }
                if (tank_o2)
                {
                    types.Add("Oxygen");
                }
                if (types.Count > 0)
                {
                    foreach (string type in types)
                    {
                        BlockSystem <IMyGasTank> tanks = BlockSystem <IMyGasTank> .SearchBlocks(DisplayLcd.program, block => block.BlockDefinition.SubtypeName.Contains(type));

                        float      volumes  = 0f;
                        float      capacity = 0f;
                        float      width    = 50f;
                        StyleGauge style    = new StyleGauge()
                        {
                            Orientation     = SpriteOrientation.Horizontal,
                            Fullscreen      = true,
                            Width           = width,
                            Height          = width,
                            Padding         = new StylePadding(0),
                            Round           = false,
                            RotationOrScale = 0.5f
                        };

                        MySprite text = new MySprite()
                        {
                            Type            = SpriteType.TEXT,
                            Color           = Color.DimGray,
                            Position        = position + new Vector2(0, 0),
                            RotationOrScale = 1f,
                            FontId          = drawing.Font,
                            Alignment       = TextAlignment.LEFT
                        };

                        tanks.ForEach(delegate(IMyGasTank block)
                        {
                            volumes  += (float)block.FilledRatio * block.Capacity;
                            capacity += block.Capacity;
                        });

                        drawing.DrawGauge(position, volumes, capacity, style);
                        position += new Vector2(0, 60);
                        switch (type)
                        {
                        case "Hydrogen":
                            text.Data = $"H2: {Math.Round(volumes, 2)}L / {Math.Round(capacity, 2)}L";
                            break;

                        case "Oxygen":
                            text.Data = $"O2: {Math.Round(volumes, 2)}L / {Math.Round(capacity, 2)}L";
                            break;
                        }
                        text.Position = position;
                        drawing.AddSprite(text);
                        position += new Vector2(0, 60);
                    }
                }
                return(position);
            }
Example #2
0
            public Vector2 Draw(Drawing drawing, Vector2 position)
            {
                if (!enable)
                {
                    return(position);
                }
                if (search)
                {
                    Search();
                }

                float      width          = drills_size;
                float      padding        = 4f;
                float      x_min          = 0f;
                float      x_max          = 0f;
                float      y_min          = 0f;
                float      y_max          = 0f;
                bool       first          = true;
                Vector2    padding_screen = new Vector2(drills_padding_x, drills_padding_y);
                StyleGauge style          = new StyleGauge()
                {
                    Orientation     = SpriteOrientation.Horizontal,
                    Fullscreen      = false,
                    Width           = width,
                    Height          = width,
                    Padding         = new StylePadding(0),
                    Round           = false,
                    RotationOrScale = 0.5f,
                    Percent         = drills_size > 49 ? true : false
                };

                if (drills_info)
                {
                    drawing.AddSprite(new MySprite()
                    {
                        Type            = SpriteType.TEXT,
                        Data            = $"Drill Number:{drill_inventories.List.Count} ({filter})",
                        Size            = new Vector2(width, width),
                        Color           = Color.DimGray,
                        Position        = position + new Vector2(0, 0),
                        RotationOrScale = 0.5f,
                        FontId          = drawing.Font,
                        Alignment       = TextAlignment.LEFT
                    });
                    position += new Vector2(0, 20);
                }
                drill_inventories.ForEach(delegate(IMyShipDrill drill)
                {
                    switch (drills_orientation)
                    {
                    case "x":
                        if (first || drill.Position.Y < x_min)
                        {
                            x_min = drill.Position.Y;
                        }
                        if (first || drill.Position.Y > x_max)
                        {
                            x_max = drill.Position.Y;
                        }
                        if (first || drill.Position.Z < y_min)
                        {
                            y_min = drill.Position.Z;
                        }
                        if (first || drill.Position.Z > y_max)
                        {
                            y_max = drill.Position.Z;
                        }
                        break;

                    case "y":
                        if (first || drill.Position.X < x_min)
                        {
                            x_min = drill.Position.X;
                        }
                        if (first || drill.Position.X > x_max)
                        {
                            x_max = drill.Position.X;
                        }
                        if (first || drill.Position.Z < y_min)
                        {
                            y_min = drill.Position.Z;
                        }
                        if (first || drill.Position.Z > y_max)
                        {
                            y_max = drill.Position.Z;
                        }
                        break;

                    default:
                        if (first || drill.Position.X < x_min)
                        {
                            x_min = drill.Position.X;
                        }
                        if (first || drill.Position.X > x_max)
                        {
                            x_max = drill.Position.X;
                        }
                        if (first || drill.Position.Y < y_min)
                        {
                            y_min = drill.Position.Y;
                        }
                        if (first || drill.Position.Y > y_max)
                        {
                            y_max = drill.Position.Y;
                        }
                        break;
                    }
                    first = false;
                });
                //drawingSurface.WriteText($"X min:{x_min} Y min:{y_min}\n", false);
                drill_inventories.ForEach(delegate(IMyShipDrill drill)
                {
                    IMyInventory block_inventory = drill.GetInventory(0);
                    long volume    = block_inventory.CurrentVolume.RawValue;
                    long maxVolume = block_inventory.MaxVolume.RawValue;
                    float x        = 0;
                    float y        = 0;
                    switch (drills_orientation)
                    {
                    case "x":
                        x = Math.Abs(drill.Position.Y - x_min);
                        y = Math.Abs(drill.Position.Z - y_min);
                        break;

                    case "y":
                        x = Math.Abs(drill.Position.X - x_min);
                        y = Math.Abs(drill.Position.Z - y_min);
                        break;

                    default:
                        x = Math.Abs(drill.Position.X - x_min);
                        y = Math.Abs(drill.Position.Y - y_min);
                        break;
                    }
                    //drawingSurface.WriteText($"X:{x} Y:{y}\n", true);
                    if (drills_flip_x)
                    {
                        x = Math.Abs(x_max - x_min) - x;
                    }
                    if (drills_flip_y)
                    {
                        y = Math.Abs(y_max - y_min) - y;
                    }
                    //drawingSurface.WriteText($"Volume [{x},{y}]:{volume}/{maxVolume}\n", true);
                    Vector2 position_relative = drills_rotate ? new Vector2(y * (width + padding), x * (width + padding)) : new Vector2(x * (width + padding), y * (width + padding));

                    drawing.DrawGauge(position + position_relative + padding_screen, volume, maxVolume, style);
                });

                return(position);
            }
Example #3
0
            public Vector2 Draw(Drawing drawing, Vector2 position)
            {
                if (!enable)
                {
                    return(position);
                }
                BlockSystem <IMyTerminalBlock> producers = BlockSystem <IMyTerminalBlock> .SearchBlocks(DisplayLcd.program, block => block.Components.Has <MyResourceSourceComponent>());

                BlockSystem <IMyTerminalBlock> consummers = BlockSystem <IMyTerminalBlock> .SearchBlocks(DisplayLcd.program, block => block.Components.Has <MyResourceSinkComponent>());

                Dictionary <string, Power> outputs = new Dictionary <string, Power>();
                Power batteries_store = new Power()
                {
                    Type = "Batteries"
                };

                outputs.Add("all", new Power()
                {
                    Type = "All"
                });
                float      current_input = 0f;
                float      max_input     = 0f;
                float      width         = 30f;
                StyleGauge style         = new StyleGauge()
                {
                    Orientation     = SpriteOrientation.Horizontal,
                    Fullscreen      = true,
                    Width           = width,
                    Height          = width,
                    Padding         = new StylePadding(0),
                    Round           = false,
                    RotationOrScale = 0.5f
                };

                MySprite text = new MySprite()
                {
                    Type            = SpriteType.TEXT,
                    Color           = Color.DimGray,
                    Position        = position + new Vector2(0, 0),
                    RotationOrScale = .6f,
                    FontId          = drawing.Font,
                    Alignment       = TextAlignment.LEFT
                };

                producers.ForEach(delegate(IMyTerminalBlock block)
                {
                    string type = block.BlockDefinition.SubtypeName;
                    if (block is IMyBatteryBlock)
                    {
                        IMyBatteryBlock battery = (IMyBatteryBlock)block;
                        batteries_store.AddCurrent(battery.CurrentStoredPower);
                        batteries_store.AddMax(battery.MaxStoredPower);
                    }
                    else
                    {
                        MyResourceSourceComponent resourceSource;
                        block.Components.TryGet <MyResourceSourceComponent>(out resourceSource);
                        if (resourceSource != null)
                        {
                            ListReader <MyDefinitionId> myDefinitionIds = resourceSource.ResourceTypes;
                            if (myDefinitionIds.Contains(PowerDefinitionId))
                            {
                                Power global_output = outputs["all"];
                                global_output.AddCurrent(resourceSource.CurrentOutputByType(PowerDefinitionId));
                                global_output.AddMax(resourceSource.MaxOutputByType(PowerDefinitionId));

                                if (!outputs.ContainsKey(type))
                                {
                                    outputs.Add(type, new Power()
                                    {
                                        Type = type
                                    });
                                }
                                Power current_output = outputs[type];
                                current_output.AddCurrent(resourceSource.CurrentOutputByType(PowerDefinitionId));
                                current_output.AddMax(resourceSource.MaxOutputByType(PowerDefinitionId));
                            }
                        }
                    }
                });

                drawing.DrawGauge(position, outputs["all"].Current, outputs["all"].Max, style);

                foreach (KeyValuePair <string, Power> kvp in outputs)
                {
                    string title = kvp.Key;

                    position += new Vector2(0, 40);
                    if (kvp.Key.Equals("all"))
                    {
                        text.Data = $"Global Generator\n Out: {Math.Round(kvp.Value.Current, 2)}MW / {Math.Round(kvp.Value.Max, 2)}MW";
                    }
                    else
                    {
                        text.Data  = $"{title} (n={kvp.Value.Count})\n";
                        text.Data += $" Out: {Math.Round(kvp.Value.Current, 2)}MW / {Math.Round(kvp.Value.Max, 2)}MW";
                        text.Data += $" (Moy={kvp.Value.Moyen}MW)";
                    }
                    text.Position = position;
                    drawing.AddSprite(text);
                }

                position += new Vector2(0, 40);
                drawing.DrawGauge(position, batteries_store.Current, batteries_store.Max, style, true);
                position     += new Vector2(0, 40);
                text.Data     = $"Battery Store (n={batteries_store.Count})\n Store: {Math.Round(batteries_store.Current, 2)}MW / {Math.Round(batteries_store.Max, 2)}MW";
                text.Position = position;
                drawing.AddSprite(text);

                consummers.ForEach(delegate(IMyTerminalBlock block)
                {
                    if (block is IMyBatteryBlock)
                    {
                    }
                    else
                    {
                        MyResourceSinkComponent resourceSink;
                        block.Components.TryGet <MyResourceSinkComponent>(out resourceSink);
                        if (resourceSink != null)
                        {
                            ListReader <MyDefinitionId> myDefinitionIds = resourceSink.AcceptedResources;
                            if (myDefinitionIds.Contains(PowerDefinitionId))
                            {
                                max_input     += resourceSink.RequiredInputByType(PowerDefinitionId);
                                current_input += resourceSink.CurrentInputByType(PowerDefinitionId);
                            }
                        }
                    }
                });
                position += new Vector2(0, 40);
                drawing.DrawGauge(position, current_input, max_input, style, true);
                position     += new Vector2(0, 40);
                text.Data     = $"Power In: {Math.Round(current_input, 2)}MW / {Math.Round(max_input, 2)}MW";
                text.Position = position;
                drawing.AddSprite(text);

                return(position + new Vector2(0, 60));
            }