示例#1
0
        public void CanSwapItemToItem()
        {
            // Arrange
            const string testName = "CanSwapItemToItem";

            SetupScenario(testName,
                          out var lifecycleManager,
                          out var nodeConfigs);

            CreatePlayer(testName,
                         nodeConfigs[0],
                         lifecycleManager,
                         out var player);

            CreateItem(TutorialScanner.Archetype.Name,
                       nodeConfigs[0],
                       lifecycleManager,
                       out var item1,
                       out var item1ContainerIndex,
                       out var item1Container);

            CreateItem(TutorialScanner.Archetype.Name,
                       nodeConfigs[0],
                       lifecycleManager,
                       out var item2,
                       out var item2ContainerIndex,
                       out var item2Container);

            // Assert Not Swapped
            Assert.AreEqual(item1Container.Item,
                            item1.Entity.Id);
            Assert.AreEqual(item2Container.Item,
                            item2.Entity.Id);

            // Act
            var swapCommand = new SwapSubsystemItemCommand
            {
                PlayerId           = player.Entity.Id,
                SubsystemId        = nodeConfigs[0].EntityId,
                FromItemId         = item1.Entity.Id,
                FromContainerIndex = item1ContainerIndex,
                ToItemId           = item2.Entity.Id,
                ToContainerIndex   = item2ContainerIndex
            };

            lifecycleManager.ECSRoot.ECS.EnqueueCommand(swapCommand);

            lifecycleManager.ECSRoot.ECS.Tick();

            // Assert Swapped
            Assert.AreEqual(item1Container.Item, item2.Entity.Id);
            Assert.AreEqual(item2Container.Item, item1.Entity.Id);
        }
示例#2
0
        public void CanSwapItemToNothing()
        {
            // Arrange
            const string testName = "CanSwapItemToNothing";

            SetupScenario(testName,
                          out var lifecycleManager,
                          out var nodeConfigs);

            CreatePlayer(testName,
                         nodeConfigs[0],
                         lifecycleManager,
                         out var player);

            CreateItem(TutorialScanner.Archetype.Name,
                       nodeConfigs[0],
                       lifecycleManager,
                       out var item1,
                       out var item1ContainerIndex,
                       out var item1Container);

            GetSubsystemItemStorage(nodeConfigs[0],
                                    lifecycleManager,
                                    out var subsystemItemStorage);

            // Assert there is only one item in thge correct location
            var item2Container = subsystemItemStorage.Component2.Items[1];

            Assert.AreEqual(subsystemItemStorage.Component2.Items[0].Item.Value,
                            item1.Entity.Id);
            Assert.IsNull(item2Container.Item);
            Assert.IsNull(subsystemItemStorage.Component2.Items[2].Item);
            Assert.IsNull(subsystemItemStorage.Component2.Items[3].Item);

            // Act
            var swapCommand = new SwapSubsystemItemCommand
            {
                PlayerId           = player.Entity.Id,
                SubsystemId        = nodeConfigs[0].EntityId,
                FromItemId         = item1.Entity.Id,
                FromContainerIndex = item1ContainerIndex,
                ToItemId           = null,
                ToContainerIndex   = 1
            };

            lifecycleManager.ECSRoot.ECS.EnqueueCommand(swapCommand);

            lifecycleManager.ECSRoot.ECS.Tick();

            // Assert Swapped
            Assert.AreEqual(item1Container.Item, null);
            Assert.AreEqual(item2Container.Item, item1.Entity.Id);
        }
示例#3
0
        public static void SwapSubsystemItem(int fromItemid, int fromContainerId, int toItemId, int toContainerId)
        {
            Log($"Request SwapSubsystemItem fromItem: {fromItemid} to: {toItemId}");
            var command = new SwapSubsystemItemCommand
            {
                PlayerId           = Director.Player.Id,
                SubsystemId        = Director.Player.CurrentLocationEntity.Id,
                FromItemId         = fromItemid,
                FromContainerIndex = fromContainerId,
                ToItemId           = toItemId,
                ToContainerIndex   = toContainerId
            };

            IssueCommand(command);
        }
示例#4
0
        public void CantSwapReleasableWithUnreleasableItem()
        {
            // Arrange
            const string testName = "CantSwapReleasableWithUnreleasableItem";

            var nodeConfigs = new []
            {
                new NodeConfig(
                    0,
                    0,
                    AntivirusWorkstation.Archetype),

                new NodeConfig(
                    0,
                    1,
                    SubsystemNode.Archetype),
            };

            SetupScenario(testName, out var lifecycleManager, nodeConfigs);

            CreatePlayer(testName,
                         nodeConfigs[0],
                         lifecycleManager,
                         out var player);

            CreateItem(TutorialScanner.Archetype.Name,
                       nodeConfigs[0],
                       lifecycleManager,
                       out var item2,
                       out var item2ContainerIndex,
                       out var item2Container);

            GetSubsystemItemStorage(nodeConfigs[0],
                                    lifecycleManager,
                                    out var subsystem1ItemStorage);

            var item1ContainerIndex = 0;
            var item1Id             = subsystem1ItemStorage.Component2.Items[item1ContainerIndex].Item;

            // Assert items are in correct locatioons
            Assert.NotNull(subsystem1ItemStorage.Component2.Items[0].Item);
            Assert.NotNull(subsystem1ItemStorage.Component2.Items[1].Item);
            Assert.AreEqual(subsystem1ItemStorage.Component2.Items[0].Item.Value, item1Id);
            Assert.AreEqual(subsystem1ItemStorage.Component2.Items[1].Item.Value, item2.Entity.Id);

            // Act
            var swapCommand = new SwapSubsystemItemCommand
            {
                PlayerId           = player.Entity.Id,
                SubsystemId        = nodeConfigs[0].EntityId,
                FromItemId         = item1Id.Value,
                FromContainerIndex = item1ContainerIndex,
                ToItemId           = item2.Entity.Id,
                ToContainerIndex   = item2ContainerIndex
            };

            lifecycleManager.ECSRoot.ECS.EnqueueCommand(swapCommand);

            lifecycleManager.ECSRoot.ECS.Tick();

            // Assert items are still in original locations
            Assert.AreEqual(subsystem1ItemStorage.Component2.Items[0].Item.Value, item1Id);
            Assert.AreEqual(subsystem1ItemStorage.Component2.Items[1].Item.Value, item2.Entity.Id);
        }
示例#5
0
        public void CantSwapOnAnotherSystem()
        {
            // Arrange
            const string testName = "CantSwapOnAnotherSystem";

            SetupScenario(testName,
                          out var lifecycleManager,
                          out var nodeConfigs);

            CreatePlayer(testName,
                         nodeConfigs[0],
                         lifecycleManager,
                         out var player);

            CreateItem(TutorialScanner.Archetype.Name,
                       nodeConfigs[1],
                       lifecycleManager,
                       out var item1,
                       out var item1ContainerIndex,
                       out var item1Container);

            CreateItem(TutorialScanner.Archetype.Name,
                       nodeConfigs[1],
                       lifecycleManager,
                       out var item2,
                       out var item2ContainerIndex,
                       out var item2Container);

            GetSubsystemItemStorage(nodeConfigs[0],
                                    lifecycleManager,
                                    out var subsystem1ItemStorage);

            GetSubsystemItemStorage(nodeConfigs[1],
                                    lifecycleManager,
                                    out var subsystem2ItemStorage);

            // Assert setup has 2 items in other system
            Assert.IsNull(subsystem1ItemStorage.Component2.Items[0].Item);
            Assert.IsNull(subsystem1ItemStorage.Component2.Items[1].Item);
            Assert.IsNull(subsystem1ItemStorage.Component2.Items[2].Item);
            Assert.IsNull(subsystem1ItemStorage.Component2.Items[3].Item);

            Assert.AreEqual(subsystem2ItemStorage.Component2.Items[0].Item, item1.Entity.Id);
            Assert.AreEqual(subsystem2ItemStorage.Component2.Items[1].Item, item2.Entity.Id);
            Assert.IsNull(subsystem2ItemStorage.Component2.Items[2].Item);
            Assert.IsNull(subsystem2ItemStorage.Component2.Items[3].Item);

            // Act
            var swapCommand = new SwapSubsystemItemCommand
            {
                PlayerId           = player.Entity.Id,
                SubsystemId        = nodeConfigs[0].EntityId,
                FromItemId         = item1.Entity.Id,
                FromContainerIndex = item1ContainerIndex,
                ToItemId           = item2.Entity.Id,
                ToContainerIndex   = item2ContainerIndex
            };

            lifecycleManager.ECSRoot.ECS.EnqueueCommand(swapCommand);

            lifecycleManager.ECSRoot.ECS.Tick();

            // Assert still has 2 items in other system
            Assert.IsNull(subsystem1ItemStorage.Component2.Items[0].Item);
            Assert.IsNull(subsystem1ItemStorage.Component2.Items[1].Item);
            Assert.IsNull(subsystem1ItemStorage.Component2.Items[2].Item);
            Assert.IsNull(subsystem1ItemStorage.Component2.Items[3].Item);

            Assert.AreEqual(subsystem2ItemStorage.Component2.Items[0].Item, item1.Entity.Id);
            Assert.AreEqual(subsystem2ItemStorage.Component2.Items[1].Item, item2.Entity.Id);
            Assert.IsNull(subsystem2ItemStorage.Component2.Items[2].Item);
            Assert.IsNull(subsystem2ItemStorage.Component2.Items[3].Item);
        }