source: 2013/30/MiskaK/MW2(My Warfare 2)/Paranneltu Jypeli/Physics2DDotNet/Ignorers/GroupCollection.cs @ 4507

Revision 4507, 9.4 KB checked in by anlakane, 6 years ago (diff)

Talletus.

Line 
1#region MIT License
2/*
3 * Copyright (c) 2005-2008 Jonathan Mark Porter. http://physics2d.googlepages.com/
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights to
8 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 * the Software, and to permit persons to whom the Software is furnished to do so,
10 * subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
16 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
19 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22#endregion
23
24
25
26#if UseDouble
27using Scalar = System.Double;
28#else
29using Scalar = System.Single;
30#endif
31using System;
32using System.Collections.Generic;
33
34namespace Physics2DDotNet.Ignorers
35{
36    /// <summary>
37    /// A collection that stores ints that represent groups
38    /// </summary>
39#if !(WINDOWS_PHONE || XBOX)
40    [Serializable]
41#endif
42    public class GroupCollection : ICollection<int>
43    {
44        public static bool Intersect(GroupCollection groups1, GroupCollection groups2)
45        {
46            List<int> g1 = groups1.groups;
47            List<int> g2 = groups2.groups;
48            int index1 = 0;
49            int index2 = 0;
50            while (index1 < g1.Count && index2 < g2.Count)
51            {
52                if (g1[index1] == g2[index2])
53                {
54                    return true;
55                }
56                else if (g1[index1] < g2[index2])
57                {
58                    index1++;
59                }
60                else
61                {
62                    index2++;
63                }
64            }
65            return false;
66        }
67
68        List<int> groups = new List<int>();
69
70        public GroupCollection()
71        {
72            groups = new List<int>();
73        }
74        public GroupCollection(GroupCollection copy)
75        {
76            this.groups = new List<int>(copy.groups);
77        }
78
79        /// <summary>
80        /// Gets the number of collison Groups the ignorer is part of.
81        /// </summary>
82        public int Count
83        {
84            get { return groups.Count; }
85        }
86        bool ICollection<int>.IsReadOnly
87        {
88            get { return false; }
89        }
90
91        /// <summary>
92        /// Trys to add a group.
93        /// </summary>
94        /// <param name="item">The group ID to add.</param>
95        /// <returns>false if the ignorer was already part of the group; otherwise false.</returns>
96        public bool Add(int item)
97        {
98            for (int index = 0; index < groups.Count; ++index)
99            {
100                if (groups[index] == item)
101                {
102                    return false;
103                }
104                if (groups[index] > item)
105                {
106                    groups.Insert(index, item);
107                    return true;
108                }
109            }
110            groups.Add(item);
111            return true;
112        }
113        /// <summary>
114        /// adds an array of group ids.
115        /// </summary>
116        /// <param name="array">The array of group IDs. (this will be sorted)</param>
117        /// <returns>the number of IDs that were not already part of the group.</returns>
118        public int AddRange(int[] array)
119        {
120            if (array == null) { throw new ArgumentNullException("collection"); }
121            Array.Sort(array);
122            List<int> newGroups = new List<int>(groups.Count + array.Length);
123
124            int newIndex = 0;
125            int oldIndex = 0;
126            int index = 0;
127            int count = 0;
128            while ((newIndex < array.Length) && (oldIndex < groups.Count))
129            {
130                if (array[newIndex] == groups[oldIndex])
131                {
132                    oldIndex++;
133                }
134                else if (array[newIndex] > groups[oldIndex])
135                {
136                    newGroups.Add(groups[oldIndex]);
137                    oldIndex++;
138                    index++;
139                }
140                else
141                {
142                    newGroups.Add(array[newIndex]);
143                    newIndex++;
144                    index++;
145                    count++;
146                }
147            }
148            for (; newIndex < array.Length; ++newIndex)
149            {
150                if (index == 0 || newGroups[index - 1] != array[newIndex])
151                {
152                    newGroups.Add(array[newIndex]);
153                    index++;
154                    count++;
155                }
156            }
157            for (; oldIndex < groups.Count; ++oldIndex)
158            {
159                if (index == 0 || newGroups[index - 1] != groups[oldIndex])
160                {
161                    newGroups.Add(groups[oldIndex]);
162                    index++;
163                }
164            }
165            this.groups = newGroups;
166            return count;
167        }
168        /// <summary>
169        /// returns true if the ignorer is part of the group.
170        /// </summary>
171        /// <param name="item">The group ID.</param>
172        /// <returns>true if the ignorer is part of the group; otherwise false.</returns>
173        public bool Contains(int item)
174        {
175            return groups.BinarySearch(item) >= 0;
176        }
177        /// <summary>
178        /// returns the number of groups in the array it is part of.
179        /// </summary>
180        /// <param name="array">The array of group IDs. (this will be sorted)</param>
181        /// <returns>The number of groups in the array it is part of.</returns>
182        public int ContainsRange(int[] array)
183        {
184            if (array == null) { throw new ArgumentNullException("collection"); }
185            Array.Sort(array);
186            int index1 = 0;
187            int index2 = 0;
188            int count = 0;
189            while (index1 < groups.Count && index2 < array.Length)
190            {
191                if (groups[index1] == array[index2])
192                {
193                    count++;
194                    index1++;
195                    index2++;
196                }
197                else if (groups[index1] < array[index2])
198                {
199                    index1++;
200                }
201                else
202                {
203                    index2++;
204                }
205            }
206            return count;
207        }
208        /// <summary>
209        /// Trys to remove the ignorer from a group.
210        /// </summary>
211        /// <param name="item">The group ID.</param>
212        /// <returns>true if the ignore was part of the group; otherwise false.</returns>
213        public bool Remove(int item)
214        {
215            int index = groups.BinarySearch(item);
216            if (index < 0) { return false; }
217            groups.RemoveAt(index);
218            return true;
219        }
220        /// <summary>
221        /// Trys to remove the ignorer from a range of groups.
222        /// </summary>
223        /// <param name="array">The array of group IDs. (this will be sorted)</param>
224        /// <returns>the number of groups the ignore was removed from.</returns>
225        public int RemoveRange(int[] array)
226        {
227            if (array == null) { throw new ArgumentNullException("collection"); }
228            Array.Sort(array);
229            int index = 0;
230            return groups.RemoveAll(delegate(int value)
231            {
232                while (index < array.Length)
233                {
234                    if (value == array[index])
235                    {
236                        index++;
237                        return true;
238                    }
239                    else if (value > array[index])
240                    {
241                        index++;
242                    }
243                    else
244                    {
245                        return false;
246                    }
247                }
248                return false;
249            });
250        }
251        /// <summary>
252        /// returns if the 2 ignores are not part of the same group.
253        /// </summary>
254        /// <param name="other">the other CollisionGroupIgnorer</param>
255        /// <returns>true if they are not part of the same group; otherwiase false.</returns>
256
257        void ICollection<int>.Add(int item)
258        {
259            Add(item);
260        }
261        /// <summary>
262        /// removes the ignorer from all groups.
263        /// </summary>
264        public void Clear()
265        {
266            groups.Clear();
267        }
268        public void CopyTo(int[] array, int arrayIndex)
269        {
270            groups.CopyTo(array, arrayIndex);
271        }
272        public IEnumerator<int> GetEnumerator()
273        {
274            return groups.GetEnumerator();
275        }
276        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
277        {
278            return GetEnumerator();
279        }
280    }
281}
Note: See TracBrowser for help on using the repository browser.