private Sprite GetSprite()
        {
            var resources = BuildingCellVisualizerResources.Instance();

            if (input)
            {
                if (this.type == ConduitType.Gas)
                {
                    return(resources.gasInputIcon);
                }
                else if (this.type == ConduitType.Liquid || this.type == ConduitType.Solid)
                {
                    return(resources.liquidInputIcon);
                }
            }
            else
            {
                if (this.type == ConduitType.Gas)
                {
                    return(resources.gasOutputIcon);
                }
                else if (this.type == ConduitType.Liquid || this.type == ConduitType.Solid)
                {
                    return(resources.liquidOutputIcon);
                }
            }

            return(null);
        }
 public static BuildingCellVisualizerResources Instance()
 {
     if ((UnityEngine.Object)_Instance == (UnityEngine.Object)null)
     {
         _Instance = Resources.Load <BuildingCellVisualizerResources>("BuildingCellVisualizerResources");
         _Instance.Initialize();
     }
     return(_Instance);
 }
        static void SwapFlowColour(BuildingCellVisualizerResources instance)
        {
            BuildingCellVisualizerResources.ConnectedDisconnectedColours input = instance.liquidIOColours.input;
            instance.liquidIOColours.input  = instance.liquidIOColours.output;
            instance.liquidIOColours.output = input;

            BuildingCellVisualizerResources.ConnectedDisconnectedColours input2 = instance.gasIOColours.input;
            instance.gasIOColours.input  = instance.gasIOColours.output;
            instance.gasIOColours.output = input2;
        }
        public static void Postfix(ref BuildingCellVisualizerResources __instance)
        {
            SwapFlowColourAssets.Options = POptions.ReadSettings <SwapFlowColourOptions>() ?? new SwapFlowColourOptions();

            if (SwapFlowColourAssets.Options.RedBlue)
            {
                RedBlue(__instance);
            }
            else
            {
                SwapFlowColour(__instance);
            }
        }
        static void RedBlue(BuildingCellVisualizerResources instance)
        {
            // Connections
            Color32 blueInputConnected    = Color.blue;
            Color32 blueInputDisconnected = Color.blue;
            Color32 redOutputConnected    = Color.red;
            Color32 redOutputDisconnected = Color.red;

            // Liquid
            instance.liquidIOColours.input.connected     = blueInputConnected;
            instance.liquidIOColours.input.disconnected  = blueInputDisconnected;
            instance.liquidIOColours.output.connected    = redOutputConnected;
            instance.liquidIOColours.output.disconnected = redOutputDisconnected;

            // Gas
            instance.gasIOColours.input.connected     = blueInputConnected;
            instance.gasIOColours.input.disconnected  = blueInputDisconnected;
            instance.gasIOColours.output.connected    = redOutputConnected;
            instance.gasIOColours.output.disconnected = redOutputDisconnected;
        }
예제 #6
0
                public static void Postfix(BuildingCellVisualizer __instance, HashedString mode)
                {
                    Traverse         traverse1 = Traverse.Create((object)__instance);
                    Building         building  = traverse1.Field("building").GetValue <Building>();
                    ISecondaryOutput component = building.Def.BuildingComplete.GetComponent <ISecondaryOutput>();

                    if (component == null || component.GetSecondaryConduitType() != ConduitType.Solid)
                    {
                        return;
                    }
                    BuildingCellVisualizerResources visualizerResources = traverse1.Field("resources").GetValue <BuildingCellVisualizerResources>();
                    Traverse traverse2 = traverse1.Field("icons");
                    Dictionary <GameObject, Image> icons = traverse2.GetValue <Dictionary <GameObject, Image> >();
                    Traverse traverse3 = traverse1.Field("secondaryOutputVisualizer");

                    if (icons == null)
                    {
                        return;
                    }
                    GameObject visualizerObj = traverse3.GetValue <GameObject>();

                    if ((UnityEngine.Object)visualizerObj == (UnityEngine.Object)null)
                    {
                        GameObject key = Util.KInstantiate(Assets.UIPrefabs.ResourceVisualizer, GameScreenManager.Instance.worldSpaceCanvas, (string)null);
                        key.transform.SetAsFirstSibling();
                        icons.Add(key, key.transform.GetChild(0).GetComponent <Image>());
                        traverse3.SetValue((object)key);
                    }
                    else
                    {
                        if (mode != OverlayModes.SolidConveyor.ID || !(bool)((UnityEngine.Object)building) || !(bool)((UnityEngine.Object)visualizerResources))
                        {
                            return;
                        }
                        CellOffset secondaryConduitOffset = component.GetSecondaryConduitOffset();
                        InfiniteSourceSinkPatches.Db_Initialize_Patch.DrawUtilityIcon(ref icons, InfiniteSourceSinkPatches.Db_Initialize_Patch.GetVisualizerCell(building, secondaryConduitOffset), visualizerResources.liquidOutputIcon, ref visualizerObj, (Color)BuildingCellVisualizer.secondOutputColour);
                        traverse3.SetValue((object)visualizerObj);
                        traverse2.SetValue((object)icons);
                    }
                }
        protected DisplayConduitPortInfo(ConduitType type, CellOffset offset, CellOffset?offsetFlipped, bool input, Color?color)
        {
            this.type   = type;
            this.offset = offset;
            this.input  = input;

            this.offsetFlipped = offsetFlipped ?? offset;

            // assign port colors
            if (color != null)
            {
                this.color = color ?? Color.white;
            }
            else
            {
                // none given. Use defaults
                var resources = BuildingCellVisualizerResources.Instance();
                var ioColors  = type == ConduitType.Gas ? resources.gasIOColours : resources.liquidIOColours;
                var colorSet  = input ? ioColors.input : ioColors.output;

                this.color = colorSet.connected;
            }
        }
예제 #8
0
 protected override void OnSpawn()
 {
     resources     = BuildingCellVisualizerResources.Instance();
     enableRaycast = ((UnityEngine.Object)(building as BuildingComplete) != (UnityEngine.Object)null);
     icons         = new Dictionary <GameObject, Image>();
 }
예제 #9
0
            public static void Postfix(HashedString mode, BuildingCellVisualizer __instance, Building ___building, BuildingCellVisualizerResources ___resources)
            {
                List <ConduitIO> ports      = MultiIOExtensions.GetAllPortsFromObject(___building.gameObject);
                Sprite           outputIcon = ___resources.gasOutputIcon;
                Sprite           inputIcon  = ___resources.gasInputIcon;

                if (OverlayModes.GasConduits.ID == mode)
                {
                    foreach (ConduitIO port in ports)
                    {
                        if (port.ConduitType == ConduitType.Gas)
                        {
                            CellOffset offset = port.CellOffset;
                            int        cell   = Grid.OffsetCell(___building.GetCell(), ___building.GetRotatedOffset(offset));
                            CallDrawUtilityIcon(__instance, cell, port is InputPort ? inputIcon : outputIcon, ref port.CellVisualizer, port.IconColor, Color.white);
                        }
                    }
                }
                else if (OverlayModes.LiquidConduits.ID == mode)
                {
                    foreach (ConduitIO port in ports)
                    {
                        if (port.ConduitType == ConduitType.Liquid)
                        {
                            CellOffset offset = port.CellOffset;
                            int        cell   = Grid.OffsetCell(___building.GetCell(), ___building.GetRotatedOffset(offset));
                            CallDrawUtilityIcon(__instance, cell, port is InputPort ? inputIcon : outputIcon, ref port.CellVisualizer, port.IconColor, Color.white);
                        }
                    }
                }
                else if (OverlayModes.SolidConveyor.ID == mode)
                {
                    foreach (ConduitIO port in ports)
                    {
                        if (port.ConduitType == ConduitType.Solid)
                        {
                            CellOffset offset = port.CellOffset;
                            int        cell   = Grid.OffsetCell(___building.GetCell(), ___building.GetRotatedOffset(offset));
                            CallDrawUtilityIcon(__instance, cell, port is InputPort ? inputIcon : outputIcon, ref port.CellVisualizer, port.IconColor, Color.white);
                        }
                    }
                }
            }
 public static void DestroyInstance()
 {
     _Instance = null;
 }