Esempio n. 1
0
        /// <summary>
        /// Method for getting and returning the <see cref="Light"/>s adjacent to the given
        /// </summary>
        /// <param name="light">The <see cref="Light"/> to get the adjacent from</param>
        /// <returns>A <see cref="List{Light}"/> adjacent to this</returns>
        public static List <Light> GetAdjacent(this List <Light> lights, Light light)
        {
            lights.EnsureNotNull(nameof(lights));
            light.EnsureNotNull(nameof(light));

            var returnValue = new List <Light>();

            if (light.X > 0)
            {
                returnValue.Add(lights.Single(l => l.X == light.X - 1 && l.Y == light.Y));
            }

            if (light.Y > 0)
            {
                returnValue.Add(lights.Single(l => l.X == light.X && l.Y == light.Y - 1));
            }

            if (light.X < 4)
            {
                returnValue.Add(lights.Single(l => l.X == light.X + 1 && l.Y == light.Y));
            }

            if (light.Y < 4)
            {
                returnValue.Add(lights.Single(l => l.X == light.X && l.Y == light.Y + 1));
            }

            return(returnValue);
        }
        internal ObjectsClickedMessage(List<SceneObject> clickedObjects)
        {
            clickedObjects.EnsureNotNull("clickedObjects");
            clickedObjects.EnsureMoreThanZeroElements("clickedObjects");

            this.ClickedObjects = clickedObjects;
        }
        public static IEnumerable <T> SynchronizeCollection <T>(this IList <T> existingSet, IEnumerable <T> newSet, bool updateExistingSet = true)
        {
            var finalSet      = updateExistingSet ? existingSet : new List <T>(existingSet);
            var itemsToRemove = new List <T>(existingSet);
            var itemsToAdd    = new List <T>();

            foreach (var newItem in newSet.EnsureNotNull())
            {
                if (itemsToRemove.Contains(newItem))
                {
                    itemsToRemove.Remove(newItem);
                }
                else
                {
                    itemsToAdd.Add(newItem);
                }
            }

            foreach (var itemToRemove in itemsToRemove.EnsureNotNull())
            {
                finalSet.Remove(itemToRemove);
            }

            foreach (var itemToAdd in itemsToAdd.EnsureNotNull())
            {
                finalSet.Add(itemToAdd);
            }

            return(finalSet);
        }
Esempio n. 4
0
        public void EnsureNotNullTest()
        {
            List <String> list = null;
            // ReSharper disable once ExpressionIsAlwaysNull
            var actual = list.EnsureNotNull();

            Assert.NotNull(actual);
            Assert.Empty(actual);
            Assert.Null(list);
        }
        internal HoveredObjectsChangedMessage(
            List<SceneObject> removedObjects,
            List<SceneObject> addedObjects)
        {
            removedObjects.EnsureNotNull("removedObjects");
            addedObjects.EnsureNotNull("addedObjects");

            this.RemovedObjects = removedObjects;
            this.AddedObjects = addedObjects;
        }
        public void NullListNonFailableTest()
        {
            List <object> list   = null;
            var           result = false;

            foreach (var item in list.EnsureNotNull())
            {
            }

            result = true;

            Assert.IsTrue(result);
        }
Esempio n. 7
0
        public void EnsureNotNullTest1()
        {
            var list = new List <String>
            {
                "1",
                "2",
                "3"
            };
            var actual     = list.EnsureNotNull();
            var actualList = actual.ToList();

            Assert.Equal(3, actualList.Count);
            Assert.Equal("1", actualList.ElementAt(0));
            Assert.Equal("2", actualList.ElementAt(1));
            Assert.Equal("3", actualList.ElementAt(2));
            Assert.Same(list, actual);
        }
        /// <summary>
        /// Updates all currently active input handlers for the given view.
        /// </summary>
        /// <param name="viewObject">The object of the view control.</param>
        /// <param name="inputHandlers">The collection of input handlers managed by the view object.</param>
        /// <param name="renderLoop">The renderloop used by the view object.</param>
        /// <param name="currentlyDispsoing">Is the view currently disposing?</param>
        internal static void UpdateInputHandlerList(
            IInputEnabledView viewObject,
            List <IInputHandler> inputHandlers,
            RenderLoop renderLoop,
            bool currentlyDispsoing)
        {
            viewObject.EnsureNotNull(nameof(viewObject));
            inputHandlers.EnsureNotNull(nameof(inputHandlers));
            renderLoop.EnsureNotNull(nameof(renderLoop));

            // Clear previous input handlers
            if (inputHandlers.Count > 0)
            {
                foreach (var actHandler in inputHandlers)
                {
                    actHandler.Stop();
                }
                inputHandlers.Clear();
            }

            // Check whether this object is disposed
            if (currentlyDispsoing)
            {
                return;
            }

            // Check for other dependencies
            if ((renderLoop == null) ||
                (renderLoop.Camera == null))
            {
                return;
            }

            // Get all possible input handlers
            inputHandlers.AddRange(GraphicsCore.Current.InputHandlers.GetInputHandler(
                                       viewObject.GetType()));

            // Start them all
            foreach (var actInputHandler in inputHandlers)
            {
                actInputHandler.Start(viewObject);
            }
        }
Esempio n. 9
0
        /// <summary>
        /// Method for clearing the screen (i.e switching all the <see cref="Light"/>s off)
        /// </summary>
        /// <param name="lights">The grid containing the <see cref="Light"/>s</param>
        /// <returns>The grid</returns>
        public static void ClearScreen(this List <Light> lights)
        {
            lights.EnsureNotNull(nameof(lights));

            lights.ForEach(l => l.SwitchOff());
        }
Esempio n. 10
0
        /// <summary>
        /// Method for getting a <see cref="Light"/> by the coords
        /// </summary>
        /// <param name="lights">The <see cref="List{Light}"/> the search</param>
        /// <param name="x">The x coord of the <see cref="Light"/> to get</param>
        /// <param name="y">The x coord of the <see cref="Light"/> to get</param>
        /// <returns>The <see cref="Light"/> matching the given coord</returns>
        public static Light GetByCoord(this List <Light> lights, int x, int y)
        {
            lights.EnsureNotNull(nameof(lights));

            return(lights.Single(l => l.X == x && l.Y == y));
        }