Exemple #1
0
        public void Test()
        {
            var test3 = new TestClass4();

            PartContainer.Fill(test3);
            PartContainer.Fill(typeof(TestClass4));
            Assert.Null(TestClass4.TestProp5);
            Assert.Null(test3.TestProp6);
            foreach (var test in new[] { TestClass4.TestProp, TestClass4.TestProp2, test3.TestProp3, test3.TestProp4 })
            {
                Assert.NotNull(test);
                Assert.Equal(2, test.Count());
                if (test.First() is TestClass1)
                {
                    Assert.IsType <TestClass1>(test.First());
                    Assert.Equal("TestClass1", test.First().ID);
                    Assert.IsType <TestClass2>(test.Last());
                    Assert.Equal("TestClass2", test.Last().ID);
                }
                else
                {
                    Assert.IsType <TestClass2>(test.First());
                    Assert.Equal("TestClass2", test.First().ID);
                    Assert.IsType <TestClass1>(test.Last());
                    Assert.Equal("TestClass1", test.Last().ID);
                }
            }
        }
Exemple #2
0
        public void Test()
        {
            var test3 = new TestClass3();

            PartContainer.Fill(test3);
            PartContainer.Fill(typeof(TestClass3));

            foreach (var test in new[] { TestClass3.TestInterface, TestClass3.TestInterface2, test3.TestInterface3, test3.TestInterface4 })
            {
                Assert.NotNull(test);
                Assert.Equal(2, test.Count);
                if (test[0] is TestClass1)
                {
                    Assert.IsType <TestClass1>(test[0]);
                    Assert.Equal("TestClass1", test[0].ID);
                    Assert.IsType <TestClass2>(test[1]);
                    Assert.Equal("TestClass2", test[1].ID);
                }
                else
                {
                    Assert.IsType <TestClass2>(test[0]);
                    Assert.Equal("TestClass2", test[0].ID);
                    Assert.IsType <TestClass1>(test[1]);
                    Assert.Equal("TestClass1", test[1].ID);
                }
            }
        }
Exemple #3
0
        public void PartBoxGetTest()
        {
            PartContainer.Noop();
            var test = new MyClass {
                Name = "blqw"
            };
            var p    = test.GetType().GetProperty("Name");
            var part = PartBox.Default.Get(p, x => new
            {
                Get = PartContainer.Invoke <Func <object, object> >("GetValue", x),
                Set = PartContainer.Invoke <Action <object, object> >("SetValue", x),
            }, p);

            Assert.NotNull(part);
            Assert.NotNull(part.Get);
            Assert.NotNull(part.Set);

            var part2 = PartBox.Default.Get(p, x => new
            {
                Get = PartContainer.Invoke <Func <object, object> >("GetValue", x),
                Set = PartContainer.Invoke <Action <object, object> >("SetValue", x),
            }, p);

            Assert.NotNull(part2);
            Assert.NotNull(part2.Get);
            Assert.NotNull(part2.Set);

            Assert.Equal(part.Get, part2.Get);
            Assert.Equal(part.Set, part2.Set);
        }
Exemple #4
0
 private void HandleArrive(PartContainer cont)
 {
     foreach (var item in containers)
     {
         if (item.partCont == cont)
         {
             item.OnReachScreen?.Invoke();
         }
     }
 }
Exemple #5
0
        public void InstanceField()
        {
            var test2 = new TestClass2();

            Assert.Null(test2.TestInterface2);
            PartContainer.Fill(test2);
            Assert.NotNull(test2.TestInterface2);
            Assert.IsType <TestClass1>(test2.TestInterface2);
            Assert.Equal("TestClass1", test2.TestInterface2.ID);
        }
Exemple #6
0
        public void Test()
        {
            var test2 = new TestClass2();

            Assert.Null(test2.GetID);
            Assert.Null(test2.GetID2);
            PartContainer.Fill(test2);
            Assert.NotNull(test2.GetID);
            Assert.NotNull(test2.GetID2);
            Assert.Equal("A", test2.GetID());
            Assert.Equal("A", test2.GetID2());
        }
Exemple #7
0
        public void Test()
        {
            var test2 = new TestClass2();

            Assert.Null(test2.Test1);
            Assert.Null(test2.Test2);
            PartContainer.Fill(test2);
            Assert.NotNull(test2.Test1);
            Assert.NotNull(test2.Test2);
            Assert.Equal(typeof(string), test2.Test1.ID);
            Assert.Equal(typeof(int), test2.Test2.ID);
        }
Exemple #8
0
        public void TestMany()
        {
            var test2 = new TestClass2();

            Assert.Null(test2.GetID3);
            PartContainer.Fill(test2);
            Assert.NotNull(test2.GetID3);
            Assert.Equal(2, test2.GetID3.Count);
            var a = test2.GetID3[0]();
            var b = test2.GetID3[1]();

            Assert.True((a == "A" && b == "B") || (a == "B" && b == "A"));
        }
Exemple #9
0
        public void Test2()
        {
            var test = new TestClass4();

            Assert.Null(test.Get1);
            Assert.Null(test.Get2);
            Assert.Null(test.Get3);
            PartContainer.Fill(test);
            Assert.NotNull(test.Get1);
            Assert.NotNull(test.Get2);
            Assert.NotNull(test.Get3);
            Assert.Equal(typeof(string), test.Get1());
            Assert.Equal(typeof(int), test.Get2());
            Assert.Equal(typeof(int), test.Get3(1));
        }
Exemple #10
0
        public void StaticPropertyAndField()
        {
            Assert.Null(TestClass3.TestInterface);
            Assert.Null(TestClass3.TestInterface2);

            PartContainer.Fill(typeof(TestClass3));

            Assert.NotNull(TestClass3.TestInterface);
            Assert.IsType <TestClass1>(TestClass3.TestInterface);
            Assert.Equal("TestClass1", TestClass3.TestInterface.ID);

            Assert.NotNull(TestClass3.TestInterface2);
            Assert.IsType <TestClass1>(TestClass3.TestInterface2);
            Assert.Equal("TestClass1", TestClass3.TestInterface2.ID);
        }
Exemple #11
0
    IEnumerator MovingTo(PartContainer target, TransitionData td)
    {
        if (target == null)
        {
            Debug.LogError("No Target assinged for transitioning! --- PlayMode will be paused");
            Debug.Break();
        }

        StartTransition();
        if (currContInfo != null)
        {
            currContInfo.partCont.StartDeactivation(); //---> Is this necessary?
        }
        yield return(new WaitForSeconds(td.waitInCurrent));

        currContInfo.partCont = target;
        MoveCamToCurrent();
        currContInfo.partCont.StartActivation();

        //Syncro
        syncroSystem.StartSequence();
        //if I am moving to GameScreen
        if (currContInfo.cointainersType == CointainersTypes.gameScreen)
        {
            //ask for tutorial stuff
            tutSystem.TryTriggerTutorial(LvlManager.instance.currentGameMode);
            print(LvlManager.instance.currentGameMode.ToString());
        }


        while (!syncroSystem.sequenceCompleted)
        {
            yield return(null);
        }


        yield return(new WaitForSeconds(td.waitLoadingMin));

        ComeBackFromTransition();
        yield return(new WaitForSeconds(td.waitInNew));

        //REFACTOR this
        //print("Transition has ended");
        HandleArrive(currContInfo.partCont);
    }
Exemple #12
0
    IEnumerator MovingTo(PartContainer target, TransitionData td)
    {
        StartTransition();
        currCont.StartDeactivation();

        yield return(new WaitForSeconds(td.waitInCurrent));


        currCont = target;
        MoveCamToCurrent();
        currCont.StartActivation();
        //OnLodingGame?.Invoke();
        yield return(new WaitForSeconds(td.waitLoadingMin));

        ComeBackFromTransition();
        yield return(new WaitForSeconds(td.waitInNew));

        print("Transition has ended");
        OnArriveToGame?.Invoke();
    }
Exemple #13
0
        public void TestInvoke()
        {
            PartContainer.Noop();
            var test = new MyClass {
                Name = "blqw"
            };
            var p      = test.GetType().GetProperty("Name");
            var getter = PartContainer.Invoke <Func <object, object> >("GetValue", p);
            var setter = PartContainer.Invoke <Action <object, object> >("SetValue", p);

            Assert.NotNull(getter);
            Assert.NotNull(setter);

            Assert.Equal(getter(test), test.Name);
            test.Name = "xxxx";
            Assert.Equal(getter(test), test.Name);
            setter(test, "yyyy");
            Assert.Equal(getter(test), test.Name);
            Assert.Equal(test.Name, "yyyy");
        }
Exemple #14
0
 public PartManager()
 {
     _partContainer = new PartContainer();
     this.Subscribe(DocManager.Inst);
     timer = new Timer(Update, _partContainer, 0, 100);
 }
Exemple #15
0
        public void Detect()
        {
            foreach (Part myCam in this.vessel.parts)
            {
                int cnt = 0;

                if (myCam.Modules != null)
                {
                    for (int i = 0; i < myCam.Modules.Count; i++)
                    {
                        if (myCam.Modules[i] is cccam)
                        {
                            cccam myCamMod = (cccam)myCam.Modules[i];

                            if (!myCams.ContainsKey(myCam.name + cnt.ToString()))
                            {
                                myCamMod.switchOn();
                                myCamMod.isOn = true;
                                myCamMod.Events["toggleOnOff"].guiName = "Switch Off";
                                PartContainer pc = new PartContainer(cnt, myCam, myCamMod);

                                myCams.Add(pc.pcIndex, pc);
                            }
                            cnt++;
                        }
                    }
                }
                else
                {
                    Debug.Log("Modules is null");
                }
            }

            foreach (Vessel ship in FlightGlobals.Vessels)
            {
                if (ship.loaded)
                {
                    foreach (Part myCam in ship.parts)
                    {
                        int cnt = 0;

                        if (myCam.Modules != null)
                        {
                            for (int i = 0; i < myCam.Modules.Count; i++)
                            {
                                if (myCam.Modules[i] is ccrcam)
                                {
                                    ccrcam myRemoteCamMod = (ccrcam)myCam.Modules[i];

                                    if (!myCams.ContainsKey(myCam.name + cnt.ToString()))
                                    {
                                        myRemoteCamMod.switchOn();
                                        myRemoteCamMod.isOn = true;
                                        myRemoteCamMod.Events["toggleOnOff"].guiName = "Switch Off";
                                        PartContainer pc = new PartContainer(cnt, myCam, myRemoteCamMod);

                                        myCams.Add(pc.pcIndex, pc);
                                    }
                                    cnt++;
                                }
                            }
                        }
                        else
                        {
                            Debug.Log("Modules is null");
                        }
                    }
                }
            }
        }
Exemple #16
0
 public PartManager()
 {
     _partContainer = new PartContainer();
     DocManager.Inst.AddSubscriber(this);
     timer = new Timer(Update, _partContainer, 0, 100);
 }
Exemple #17
0
 public PartManager()
 {
     _partContainer = new PartContainer();
     this.Subscribe(DocManager.Inst);
     timer = new Timer(Update, _partContainer, 0, 100);
 }
Exemple #18
0
        public TutorialContainer parseTutorialFromXmlString(XmlNode xmlDocument)
        {
            var parts = xmlDocument.SelectSingleNode("TutorialSequence");

            var tutorialContainer = new TutorialContainer();

            if (parts != null)
            {
                // Then goes through each element
                foreach (XmlNode part in parts.ChildNodes)
                {
                    var partIdString = ParseHelper.getAttributeValueByName(part, "id");
                    if (!int.TryParse(partIdString, out var partId))
                    {
                        throw new Exception($"Could not parse part ID: {partIdString}");
                    }

                    var partContainer = new PartContainer(partId);
                    tutorialContainer.addPart(partContainer);

                    var checkEvents  = part.SelectNodes("CheckEvent");
                    var helpDisplays = part.SelectNodes("HelpDisplay");
                    var uiMasks      = part.SelectNodes("TutorialUiMask");

                    if (checkEvents != null)
                    {
                        foreach (XmlNode checkEvent in checkEvents)
                        {
                            var typeString = ParseHelper.getAttributeValueByName(checkEvent, "type");
                            if (!Enum.TryParse(typeString, out CheckEventType checkEventType))
                            {
                                throw new Exception($"Could not parse EventType: {typeString}");
                            }

                            var idString = ParseHelper.getAttributeValueByName(checkEvent, "id");
                            if (!int.TryParse(idString, out var id))
                            {
                                throw new Exception($"Could not parse id: {idString}");
                            }

                            if (checkEventType == CheckEventType.ElementEvent || checkEventType == CheckEventType.PartElementEvent)
                            {
                                var elementIdString = ParseHelper.getAttributeValueByName(checkEvent, "elementId");
                                if (!int.TryParse(elementIdString, out var elementId))
                                {
                                    throw new Exception($"Could not parse elementId: {elementIdString}");
                                }
                                if (checkEventType == CheckEventType.ElementEvent)
                                {
                                    partContainer.addElement(new ElementCheckEvent(checkEvent.InnerText, elementId),
                                                             id);
                                }
                                else
                                {
                                    partIdString = ParseHelper.getAttributeValueByName(checkEvent, "partId");
                                    if (!int.TryParse(partIdString, out partId))
                                    {
                                        throw new Exception($"Could not parse partId: {partIdString}");
                                    }
                                    partContainer.addElement(new PartElementCheckEvent(checkEvent.InnerText,
                                                                                       partId, elementId), id);
                                }
                            }
                            else if (checkEventType == CheckEventType.GameObjectEvent)
                            {
                                var gameObjectName = ParseHelper.getAttributeValueByName(checkEvent, "name");
                                partContainer.addElement(new GameObjectCheckEvent(checkEvent.InnerText,
                                                                                  gameObjectName), id);
                            }
                        }
                    }

                    if (helpDisplays != null)
                    {
                        foreach (XmlNode helpDisplay in helpDisplays)
                        {
                            var typeString = ParseHelper.getAttributeValueByName(helpDisplay, "type");
                            if (!Enum.TryParse(typeString, out HelpDisplayType helpDisplayType))
                            {
                                throw new Exception($"Could not parse EventType: {typeString}");
                            }

                            var idString = ParseHelper.getAttributeValueByName(helpDisplay, "id");
                            if (!int.TryParse(idString, out var id))
                            {
                                throw new Exception($"Could not parse id: {idString}");
                            }

                            var parameters     = new Dictionary <string, string>();
                            var parameterNodes = helpDisplay.SelectNodes("Parameter");
                            foreach (XmlNode parameterNode in parameterNodes)
                            {
                                var attributeName = parameterNode.Attributes[0].Value;
                                parameters.Add(attributeName, parameterNode.InnerText);
                            }

                            partContainer.addElement(new HelpDisplayInitializer(helpDisplayType, parameters), id);
                        }
                    }

                    if (uiMasks != null)
                    {
                        foreach (XmlNode uiMask in uiMasks)
                        {
                            var idString = ParseHelper.getAttributeValueByName(uiMask, "id");
                            if (!int.TryParse(idString, out var id))
                            {
                                throw new Exception($"Could not parse id: {idString}");
                            }

                            var parameters     = new Dictionary <string, string>();
                            var parameterNodes = uiMask.SelectNodes("Parameter");
                            foreach (XmlNode parameterNode in parameterNodes)
                            {
                                var attributeName = parameterNode.Attributes[0].Value;
                                parameters.Add(attributeName, parameterNode.InnerText);
                            }

                            partContainer.addElement(new TutorialUiMaskInitializer(parameters), id);
                        }
                    }
                }
            }

            return(tutorialContainer);
        }