示例#1
0
        private void setEquipmentActive(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.MSG:
                if (msg != null)
                {
                    msg.SetActive(msgSlot.isEquipmentInstalled());
                }
                else
                {
                    initERacksActive();
                    if (msg != null)
                    {
                        msg.SetActive(msgSlot.isEquipmentInstalled());
                    }
                }
                break;

            case EquipmentRacks.USU:
                if (usu != null)
                {
                    usu.SetActive(usuSlot.isEquipmentInstalled());
                }
                else
                {
                    initERacksActive();
                    if (usu != null)
                    {
                        usu.SetActive(usuSlot.isEquipmentInstalled());
                    }
                }
                break;
            }
        }
        public static LabEquipment getLabEquipmentFromNode(ConfigNode node, Lab lab)
        {
            if (node.name != CONFIG_NODE_NAME)
            {
                NE_Helper.logError("getLabEquipmentFromNode: invalid Node: " + node.name);
                return(getNullObject());
            }

            string abb  = node.GetValue(ABB_VALUE);
            string name = node.GetValue(NAME_VALUE);
            float  mass = NE_Helper.GetValueAsFloat(node, MASS_VALUE);
            float  cost = NE_Helper.GetValueAsFloat(node, COST_VALUE);

            string product        = node.GetValue(PRODUCT_VALUE);
            float  productPerHour = NE_Helper.GetValueAsFloat(node, PRODUCT_PER_HOUR_VALUE);

            string reactant           = node.GetValue(REACTANT_VALUE);
            float  reactantPerProduct = NE_Helper.GetValueAsFloat(node, REACTANT_PER_PRODUCT_VALUE);

            EquipmentRacks type = EquipmentRacksFactory.getType(node.GetValue(TYPE_VALUE));

            LabEquipment eq = new LabEquipment(abb, name, type, mass, cost, productPerHour, product, reactantPerProduct, reactant);

            eq.lab = lab;
            ConfigNode expNode = node.GetNode(ExperimentData.CONFIG_NODE_NAME);

            if (expNode != null)
            {
                eq.loadExperiment(ExperimentData.getExperimentDataFromNode(expNode));
            }

            return(eq);
        }
 public LabEquipmentSlot(EquipmentRacks t, LabEquipment e = null)
 {
     type = t;
     if (e != null && type == e.getType())
     {
         equ = e;
     }
 }
示例#4
0
 public LabEquipmentSlot(EquipmentRacks t, LabEquipment e = null)
 {
     type = t;
     if (e != null && type == e.getType())
     {
         equ = e;
     }
 }
        private static LabEquipment getLabEquipment(Part part, EquipmentRacks type)
        {
            LabEquipmentModule lem = part.GetComponent <LabEquipmentModule>();
            float mass             = part.partInfo.partPrefab.mass;
            float cost             = part.partInfo.cost;

            return(new LabEquipment(lem.abbreviation, lem.eqName, type, mass, cost, lem.productPerHour, lem.product, lem.reactantPerProduct, lem.reactant));
        }
 public ExperimentData(string id, string type, string name, string abb, EquipmentRacks eq, float mass)
 {
     this.id         = id;
     this.type       = type;
     this.name       = name;
     this.abb        = abb;
     this.mass       = mass;
     neededEquipment = eq;
 }
 public bool hasEquipmentFreeExperimentSlot(EquipmentRacks rack)
 {
     switch (rack)
     {
         case EquipmentRacks.KEMINI:
             return keminiSlot.experimentSlotFree();
         default:
             return false;
     }
 }
        public bool hasEquipmentInstalled(EquipmentRacks rack)
        {
            switch (rack)
            {
                case EquipmentRacks.KEMINI:
                    return keminiSlot.isEquipmentInstalled();

                default:
                    return false;
            }
        }
示例#9
0
        public bool hasEquipmentFreeExperimentSlot(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.KEMINI:
                return(keminiSlot.experimentSlotFree());

            default:
                return(false);
            }
        }
示例#10
0
        public bool isEquipmentRunning(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.MSG:
                return(keminiSlot.isEquipmentRunning());

            default:
                return(false);
            }
        }
示例#11
0
        public bool hasEquipmentInstalled(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.KEMINI:
                return(keminiSlot.isEquipmentInstalled());

            default:
                return(false);
            }
        }
示例#12
0
 private EquipmentRackContainer getRackModule(EquipmentRacks equipmentRack)
 {
     EquipmentRackContainer[] modules = GameObject.FindObjectsOfType(typeof(EquipmentRackContainer)) as EquipmentRackContainer[];
     for (int idx = 0, count = modules.Length; idx < count; idx++)
     {
         var module = modules[idx];
         if (module.vessel == this.vessel && module.getRackType() == equipmentRack)
         {
             return(module);
         }
     }
     return(null);
 }
        public LabEquipment(string abb, string name, EquipmentRacks type, float mass, float productPerHour, string product, float reactantPerProduct, string reactant)
        {
            this.abb  = abb;
            this.name = name;
            this.type = type;
            this.mass = mass;

            this.product        = product;
            this.productPerHour = productPerHour;

            this.reactant           = reactant;
            this.reactantPerProduct = reactantPerProduct;
        }
        public LabEquipment(string abb, string name, EquipmentRacks type, float mass, float productPerHour, string product, float reactantPerProduct, string reactant)
        {
            this.abb = abb;
            this.name = name;
            this.type = type;
            this.mass = mass;

            this.product = product;
            this.productPerHour = productPerHour;

            this.reactant = reactant;
            this.reactantPerProduct = reactantPerProduct;
        }
 /// <summary>
 /// Creates a new Experiment data object
 /// </summary>
 /// <param name="id"></param>
 /// <param name="type"></param>
 /// <param name="name">This should be a localisation tag for the "display name".</param>
 /// <param name="abb"></param>
 /// <param name="eq"></param>
 /// <param name="mass"></param>
 /// <param name="cost"></param>
 public ExperimentData(string id, string type, string name, string abb, EquipmentRacks eq, float mass, float cost)
 {
     this.id   = id;
     this.type = type;
     if (!Localizer.TryGetStringByTag(name, out this.name))
     {
         this.name = name;
     }
     this.abb        = abb;
     this.mass       = mass;
     this.cost       = cost;
     neededEquipment = eq;
 }
        private EquipmentRackContainer getRackModul(EquipmentRacks equipmentRack)
        {
            List <EquipmentRackContainer> moduls = new List <EquipmentRackContainer>(GameObject.FindObjectsOfType(typeof(EquipmentRackContainer)) as EquipmentRackContainer[]);

            foreach (EquipmentRackContainer modul in moduls)
            {
                if (modul.vessel == this.vessel && modul.getRackType() == equipmentRack)
                {
                    return(modul);
                }
            }

            return(null);
        }
示例#17
0
        public bool isEquipmentRunning(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.MSG:
                return(msgSlot.isEquipmentRunning());

            case EquipmentRacks.USU:
                return(usuSlot.isEquipmentRunning());

            default:
                return(false);
            }
        }
示例#18
0
        public bool hasEquipmentFreeExperimentSlot(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.MSG:
                return(msgSlot.experimentSlotFree());

            case EquipmentRacks.USU:
                return(usuSlot.experimentSlotFree());

            default:
                return(false);
            }
        }
示例#19
0
        public bool hasEquipmentInstalled(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.MSG:
                return(msgSlot.isEquipmentInstalled());

            case EquipmentRacks.USU:
                return(usuSlot.isEquipmentInstalled());

            default:
                return(false);
            }
        }
示例#20
0
        private void setEquipmentActive(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.FIR:
                if (fir != null)
                {
                    fir.SetActive(firSlot.isEquipmentInstalled());
                }
                else
                {
                    initERacksActive();
                    if (fir != null)
                    {
                        fir.SetActive(firSlot.isEquipmentInstalled());
                    }
                }
                break;

            case EquipmentRacks.CIR:
                if (cir != null)
                {
                    cir.SetActive(cirSlot.isEquipmentInstalled());
                }
                else
                {
                    initERacksActive();
                    if (cir != null)
                    {
                        cir.SetActive(cirSlot.isEquipmentInstalled());
                    }
                }
                break;

            case EquipmentRacks.PRINTER:
                if (printer != null)
                {
                    printer.SetActive(printerSlot.isEquipmentInstalled());
                }
                else
                {
                    initERacksActive();
                    if (printer != null)
                    {
                        printer.SetActive(printerSlot.isEquipmentInstalled());
                    }
                }
                break;
            }
        }
 private GameDatabase.TextureInfo getTexture(EquipmentRacks p)
 {
     KeyValuePair<string,string> textureName;
     if (textureNameReg.TryGetValue(p, out textureName))
     {
         GameDatabase.TextureInfo newTex = GameDatabase.Instance.GetTextureInfoIn(textureName.Key, textureName.Value);
         if (newTex != null)
         {
             return newTex;
         }
     }
     NE_Helper.logError("Could not load texture for Exp: " + p);
     return null;
 }
示例#22
0
        private GameDatabase.TextureInfo getTexture(EquipmentRacks p)
        {
            KeyValuePair <string, string> textureName;

            if (textureNameReg.TryGetValue(p, out textureName))
            {
                GameDatabase.TextureInfo newTex = GameDatabase.Instance.GetTextureInfoIn(textureName.Key, textureName.Value);
                if (newTex != null)
                {
                    return(newTex);
                }
            }
            NE_Helper.logError("Could not load texture for Exp: " + p);
            return(null);
        }
示例#23
0
        public bool hasEquipmentFreeExperimentSlot(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.CIR:
                return(cirSlot.experimentSlotFree());

            case EquipmentRacks.FIR:
                return(firSlot.experimentSlotFree());

            case EquipmentRacks.PRINTER:
                return(printerSlot.experimentSlotFree());

            default:
                return(false);
            }
        }
示例#24
0
        public static LabEquipmentSlot getLabEquipmentSlotFromConfigNode(ConfigNode node, Lab lab)
        {
            if (node == null || node.name != CONFIG_NODE_NAME)
            {
                NE_Helper.logError("getLabEquipmentFromNode: invalid Node: " + node == null? "NULL" : node.name);
                return(new LabEquipmentSlot(EquipmentRacks.NONE));
            }
            EquipmentRacks type   = EquipmentRacksFactory.getType(node.GetValue(TYPE_VALUE));
            LabEquipment   le     = null;
            ConfigNode     leNode = node.GetNode(LabEquipment.CONFIG_NODE_NAME);

            if (leNode != null)
            {
                le = LabEquipment.getLabEquipmentFromNode(leNode, lab);
            }
            return(new LabEquipmentSlot(type, le));
        }
示例#25
0
        public bool isEquipmentRunning(EquipmentRacks rack)
        {
            switch (rack)
            {
            case EquipmentRacks.CIR:
                return(cirSlot.isEquipmentRunning());

            case EquipmentRacks.FIR:
                return(firSlot.isEquipmentRunning());

            case EquipmentRacks.PRINTER:
                return(printerSlot.isEquipmentRunning());

            default:
                return(false);
            }
        }
示例#26
0
 internal GameDatabase.TextureInfo getTextureForEquipment(EquipmentRacks type)
 {
     GameDatabase.TextureInfo tex;
     if (textureReg.TryGetValue(type, out tex))
     {
         return(tex);
     }
     else
     {
         NE_Helper.log("Loading Texture for experiment: " + type);
         GameDatabase.TextureInfo newTex = getTexture(type);
         if (newTex != null)
         {
             textureReg.Add(type, newTex);
             return(newTex);
         }
         else
         {
             NE_Helper.logError("Texture for: " + type + " not found try to return default texture");
             newTex = getTexture(EquipmentRacks.NONE);
             return(newTex);
         }
     }
 }
 internal GameDatabase.TextureInfo getTextureForEquipment(EquipmentRacks type)
 {
     GameDatabase.TextureInfo tex;
     if (textureReg.TryGetValue(type, out tex))
     {
         return tex;
     }
     else
     {
         NE_Helper.log("Loading Texture for experiment: " + type);
         GameDatabase.TextureInfo newTex = getTexture(type);
         if (newTex != null)
         {
             textureReg.Add(type, newTex);
             return newTex;
         }
         else
         {
             NE_Helper.logError("Texture for: " + type + " not found try to return default texture");
             newTex = getTexture(EquipmentRacks.NONE);
             return newTex;
         }
     }
 }
        public bool hasEquipmentInstalled(EquipmentRacks rack)
        {
            switch (rack)
            {
                case EquipmentRacks.MSG:
                    return msgSlot.isEquipmentInstalled();
                case EquipmentRacks.USU:
                    return usuSlot.isEquipmentInstalled();

                default:
                    return false;
            }
        }
示例#29
0
        private static LabEquipment getLabEquipment(Part part, EquipmentRacks type)
        {
            LabEquipmentModule lem = part.GetComponent <LabEquipmentModule>();

            return(new LabEquipment(lem.abbreviation, lem.eqName, type, part.mass, lem.productPerHour, lem.product, lem.reactantPerProduct, lem.reactant));
        }
 protected KerbalResearchExperimentData(string id, string type, string name, string abb, EquipmentRacks eq, float mass, int testSubjectsNeeded)
     : base(id, type, name, abb, eq, mass, testSubjectsNeeded)
 {
     this.testSubjectsNeeded = testSubjectsNeeded;
 }
        public bool hasEquipmentInstalled(EquipmentRacks rack)
        {
            switch (rack)
            {
                case EquipmentRacks.CIR:
                    return cirSlot.isEquipmentInstalled();

                case EquipmentRacks.FIR:
                    return firSlot.isEquipmentInstalled();

                case EquipmentRacks.PRINTER:
                    return printerSlot.isEquipmentInstalled();

                default:
                    return false;
            }
        }
 internal bool hasEquipmentFreeExperimentSlot(EquipmentRacks neededEquipment)
 {
     return exposureSlot.experimentSlotFree();
 }
        public bool isEquipmentRunning(EquipmentRacks rack)
        {
            switch (rack)
            {
                case EquipmentRacks.CIR:
                    return cirSlot.isEquipmentRunning();

                case EquipmentRacks.FIR:
                    return firSlot.isEquipmentRunning();

                case EquipmentRacks.PRINTER:
                    return printerSlot.isEquipmentRunning();

                default:
                    return false;
            }
        }
 protected MPLExperimentData(string id, string type, string name, string abb, EquipmentRacks eq, float mass)
     : base(id, type, name, abb, eq, mass)
 {
 }
 private void setEquipmentActive(EquipmentRacks rack)
 {
     switch (rack)
     {
         case EquipmentRacks.MSG:
             if (msg != null)
             {
                 msg.SetActive(msgSlot.isEquipmentInstalled());
             }
             else
             {
                 initERacksActive();
                 if (msg != null) msg.SetActive(msgSlot.isEquipmentInstalled());
             }
             break;
         case EquipmentRacks.USU:
             if (usu != null)
             {
                 usu.SetActive(usuSlot.isEquipmentInstalled());
             }
             else
             {
                 initERacksActive();
                 if (usu != null) usu.SetActive(usuSlot.isEquipmentInstalled());
             }
             break;
     }
 }
 private void setEquipmentActive(EquipmentRacks rack)
 {
     switch (rack)
     {
         case EquipmentRacks.FIR:
             if (fir != null)
             {
                 fir.SetActive(firSlot.isEquipmentInstalled());
             }
             else
             {
                 initERacksActive();
                 if(fir != null)fir.SetActive(firSlot.isEquipmentInstalled());
             }
             break;
         case EquipmentRacks.CIR:
             if (cir != null)
             {
                 cir.SetActive(cirSlot.isEquipmentInstalled());
             }
             else
             {
                 initERacksActive();
                 if (cir != null) cir.SetActive(cirSlot.isEquipmentInstalled());
             }
             break;
         case EquipmentRacks.PRINTER:
             if (printer != null)
             {
                 printer.SetActive(printerSlot.isEquipmentInstalled());
             }
             else
             {
                 initERacksActive();
                 if (printer != null) printer.SetActive(printerSlot.isEquipmentInstalled());
             }
             break;
     }
 }
        public bool hasEquipmentFreeExperimentSlot(EquipmentRacks rack)
        {
            switch (rack)
            {
                case EquipmentRacks.CIR:
                    return cirSlot.experimentSlotFree();

                case EquipmentRacks.FIR:
                    return firSlot.experimentSlotFree();

                case EquipmentRacks.PRINTER:
                    return printerSlot.experimentSlotFree();

                default:
                    return false;
            }
        }
 protected MultiStepExperimentData(string id, string type, string name, string abb, EquipmentRacks eq, float mass, float cost, int numSteps)
     : base(id, type, name, abb, eq, mass, cost)
 {
     if (numSteps < 1)
     {
         throw new ArgumentOutOfRangeException("numSteps", "MultiStepExperimentData must have at least 1 step.");
     }
     steps = new T[numSteps];
 }
 protected StepExperimentData(string id, string type, string name, string abb, EquipmentRacks eq, float mass, float cost)
     : base(id, type, name, abb, eq, mass, cost)
 {
 }
        public bool isEquipmentRunning(EquipmentRacks rack)
        {
            switch (rack)
            {
                case EquipmentRacks.MSG:
                    return msgSlot.isEquipmentRunning();
                case EquipmentRacks.USU:
                    return usuSlot.isEquipmentRunning();

                default:
                    return false;
            }
        }
示例#41
0
 private bool checkForRackModule(EquipmentRacks equipmentRack)
 {
     return(getRackModule(equipmentRack) != null);
 }
        private EquipmentRackContainer getRackModul(EquipmentRacks equipmentRack)
        {
            List<EquipmentRackContainer> moduls = new List<EquipmentRackContainer>(GameObject.FindObjectsOfType(typeof(EquipmentRackContainer)) as EquipmentRackContainer[]);

            foreach (EquipmentRackContainer modul in moduls)
            {
                if (modul.vessel == this.vessel && modul.getRackType() == equipmentRack)
                {
                    return modul;
                }
            }

            return null;
        }
示例#43
0
 protected MEPExperimentData(string id, string type, string name, string abb, EquipmentRacks eq, float mass, int numSteps)
     : base(id, type, name, abb, eq, mass, numSteps)
 {
 }
示例#44
0
 internal bool hasEquipmentFreeExperimentSlot(EquipmentRacks neededEquipment)
 {
     return(exposureSlot.experimentSlotFree());
 }
        public bool isEquipmentRunning(EquipmentRacks rack)
        {
            switch (rack)
            {
                case EquipmentRacks.MSG:
                    return keminiSlot.isEquipmentRunning();

                default:
                    return false;
            }
        }
        public bool hasEquipmentFreeExperimentSlot(EquipmentRacks rack)
        {
            switch (rack)
            {
                case EquipmentRacks.MSG:
                    return msgSlot.experimentSlotFree();
                case EquipmentRacks.USU:
                    return usuSlot.experimentSlotFree();

                default:
                    return false;
            }
        }
 protected MSLExperimentData(string id, string type, string name, string abb, EquipmentRacks eq, float mass)
     : base(id, type, name, abb, eq, mass)
 {
 }
 private static LabEquipment getLabEquipment(Part part, EquipmentRacks type)
 {
     LabEquipmentModule lem = part.GetComponent<LabEquipmentModule>();
     return new LabEquipment(lem.abbreviation, lem.eqName, type, part.mass, lem.productPerHour, lem.product, lem.reactantPerProduct, lem.reactant);
 }