diff --git a/Quadtree.cs b/Quadtree.cs
index db1036a..2acaac9 100644
--- a/Quadtree.cs
+++ b/Quadtree.cs
@@ -21,31 +21,31 @@ namespace Quadtree
         /// Maximum number of items in a leaf vertex before it is split, unless the depth of the leaf is greater or
         /// equal to the maximum tree depth.
         /// </summary>
-        private readonly int m_maxLeafSize;
+        private readonly int _maxLeafSize;
 
         /// <summary>
         /// Maximum depth of the quadtree, that is the maximum allowed length of the path from the root to a new leaf
         /// when determining whether a leaf vertex may be split.
         /// </summary>
-        private readonly int m_maxTreeDepth;
+        private readonly int _maxTreeDepth;
 
         /// <summary>
         /// The list of quadtree vertices. The root vertex is always the first item. The four child vertices of a branch
         /// are always created together and stored contiguously.
         /// </summary>
-        private readonly List<QuadtreeVertex> m_vertices;
+        private readonly List<QuadtreeVertex> _vertices;
 
         /// <summary>
         /// The list of all items stored in the quadtree.
         /// </summary>
-        private readonly List<QuadtreeItem<IWorldObject>> m_items;
+        private readonly List<QuadtreeItem<IWorldObject>> _items;
 
-        private BoundingBox2 m_rootBoundingBox;
+        private BoundingBox2 _rootBoundingBox;
 
         /// <summary>
         /// The maximum bounding radius of all stored objects, used to inflate the bounding box for queries.
         /// </summary>
-        private float m_maxObjectRadius;
+        private float _maxObjectRadius;
 
         /// <summary>
         /// Stack of vertex indices with their bounding boxes. It is reused for each query.
@@ -59,26 +59,26 @@ namespace Quadtree
 
         public Quadtree(int maxLeafSize, int maxTreeDepth)
         {
-            m_maxLeafSize = maxLeafSize;
-            m_maxTreeDepth = maxTreeDepth;
-            m_vertices = new List<QuadtreeVertex>() { new QuadtreeVertex(-1, 0) };
-            m_items = new List<QuadtreeItem<IWorldObject>>();
-            m_rootBoundingBox = new BoundingBox2(Vector2.Zero, Vector2.Zero);
-            m_maxObjectRadius = 0f;
+            _maxLeafSize = maxLeafSize;
+            _maxTreeDepth = maxTreeDepth;
+            _vertices = new List<QuadtreeVertex>() { new QuadtreeVertex(-1, 0) };
+            _items = new List<QuadtreeItem<IWorldObject>>();
+            _rootBoundingBox = new BoundingBox2(Vector2.Zero, Vector2.Zero);
+            _maxObjectRadius = 0f;
             _queryStack = new Stack<QuadtreeQuery>();
             _vertexStack = new Stack<int>();
         }
 
         public void Add(IWorldObject obj)
         {
-            var itemIndex = m_items.Count;
-            m_items.Add(new QuadtreeItem<IWorldObject>(obj));
-            if (m_maxObjectRadius < obj.BoundingRadius)
+            var itemIndex = _items.Count;
+            _items.Add(new QuadtreeItem<IWorldObject>(obj));
+            if (_maxObjectRadius < obj.BoundingRadius)
             {
-                m_maxObjectRadius = obj.BoundingRadius;
+                _maxObjectRadius = obj.BoundingRadius;
             }
 
-            if (m_vertices.Count == 1 && m_vertices[0].ChildCount < m_maxLeafSize)
+            if (_vertices.Count == 1 && _vertices[0].ChildCount < _maxLeafSize)
             {
                 // Before doing any splitting, the initial quadtree root vertex is filled up in order to get a
                 // reasonable guess for what the world space is. This space can be expanded later if that assumption
@@ -88,13 +88,13 @@ namespace Quadtree
             else
             {
                 // Expands the root until the new world object fits.
-                while (!m_rootBoundingBox.Contains(obj.Position))
+                while (!_rootBoundingBox.Contains(obj.Position))
                 {
                     ExpandRoot(obj.Position);
                 }
 
-                (int leafIndex, int depth, BoundingBox2 bounds) = FindLeaf(0, m_rootBoundingBox, 0, obj.Position);
-                while (m_vertices[leafIndex].ChildCount >= m_maxLeafSize && depth < m_maxTreeDepth)
+                (int leafIndex, int depth, BoundingBox2 bounds) = FindLeaf(0, _rootBoundingBox, 0, obj.Position);
+                while (_vertices[leafIndex].ChildCount >= _maxLeafSize && depth < _maxTreeDepth)
                 {
                     // Splits the vertex and decends into one of the new leaves.
                     SplitLeaf(leafIndex, bounds);
@@ -107,28 +107,28 @@ namespace Quadtree
         public bool Remove(IWorldObject obj)
         {
             // Finds the leaf that should contain the world object.
-            (int leafIndex, _, _) = FindLeaf(0, m_rootBoundingBox, 0, obj.Position);
+            (int leafIndex, _, _) = FindLeaf(0, _rootBoundingBox, 0, obj.Position);
 
             // Tries to find the item of the world object.
             int previous = -1;
-            int current = m_vertices[leafIndex].FirstChildIndex;
+            int current = _vertices[leafIndex].FirstChildIndex;
             while (current != -1)
             {
-                QuadtreeItem<IWorldObject> item = m_items[current];
+                QuadtreeItem<IWorldObject> item = _items[current];
                 if (item.WorldObject == obj)
                 {
                     // Removes the found item from the leaf vertex.
-                    QuadtreeVertex leaf = m_vertices[leafIndex];
+                    QuadtreeVertex leaf = _vertices[leafIndex];
                     leaf.ChildCount--;
                     if (previous != -1)
                     {
-                        m_items[previous] = new QuadtreeItem<IWorldObject>(m_items[previous].WorldObject, item.Next);
+                        _items[previous] = new QuadtreeItem<IWorldObject>(_items[previous].WorldObject, item.Next);
                     }
                     else
                     {
                         leaf.FirstChildIndex = item.Next;
                     }
-                    m_vertices[leafIndex] = leaf;
+                    _vertices[leafIndex] = leaf;
 
                     // Removes the found item from the item list.
                     RemoveFromItems(current);
@@ -146,15 +146,15 @@ namespace Quadtree
         public void Query(BoundingBox2 box, List<IWorldObject> resultList)
         {
             BoundingBox2 inflatedBox = box;
-            inflatedBox.Expand(m_maxObjectRadius);
+            inflatedBox.Expand(_maxObjectRadius);
 
-            QueryProcessChildVertex(inflatedBox, box, 0, m_rootBoundingBox, resultList, _queryStack);
+            QueryProcessChildVertex(inflatedBox, box, 0, _rootBoundingBox, resultList, _queryStack);
 
             while (_queryStack.Count > 0)
             {
                 QuadtreeQuery query = _queryStack.Pop();
 
-                int childIndex = m_vertices[query.VertexIndex].FirstChildIndex;
+                int childIndex = _vertices[query.VertexIndex].FirstChildIndex;
                 BoundingBox2 halfBounds = new BoundingBox2(query.VertexBounds.Center, query.VertexBounds.Max);
                 Vector2 halfSize = halfBounds.Size;
                 QueryProcessChildVertex(inflatedBox, box, childIndex++, halfBounds, resultList, _queryStack);
@@ -172,11 +172,11 @@ namespace Quadtree
 
         public void Clear()
         {
-            m_vertices.Clear();
-            m_vertices.Add(new QuadtreeVertex(-1, 0));
-            m_items.Clear();
-            m_rootBoundingBox = new BoundingBox2(Vector2.Zero, Vector2.Zero);
-            m_maxObjectRadius = 0f;
+            _vertices.Clear();
+            _vertices.Add(new QuadtreeVertex(-1, 0));
+            _items.Clear();
+            _rootBoundingBox = new BoundingBox2(Vector2.Zero, Vector2.Zero);
+            _maxObjectRadius = 0f;
         }
 
         /// <summary>
@@ -186,92 +186,92 @@ namespace Quadtree
         private void ExpandRoot(Vector2 position)
         {
             // Finds the new index for the old root vertex and expands the bounds.
-            QuadtreeVertex newRoot = new QuadtreeVertex(m_vertices.Count, -1);
-            int oldRootIndex = m_vertices.Count;
-            if (position.X > m_rootBoundingBox.Max.X)
+            QuadtreeVertex newRoot = new QuadtreeVertex(_vertices.Count, -1);
+            int oldRootIndex = _vertices.Count;
+            if (position.X > _rootBoundingBox.Max.X)
             {
                 oldRootIndex++;
-                m_rootBoundingBox.Max.X += m_rootBoundingBox.Max.X - m_rootBoundingBox.Min.X;
+                _rootBoundingBox.Max.X += _rootBoundingBox.Max.X - _rootBoundingBox.Min.X;
             }
             else
             {
-                m_rootBoundingBox.Min.X += m_rootBoundingBox.Min.X - m_rootBoundingBox.Max.X;
+                _rootBoundingBox.Min.X += _rootBoundingBox.Min.X - _rootBoundingBox.Max.X;
             }
-            if (position.Y > m_rootBoundingBox.Max.Y)
+            if (position.Y > _rootBoundingBox.Max.Y)
             {
                 oldRootIndex += 2;
-                m_rootBoundingBox.Max.Y += m_rootBoundingBox.Max.Y - m_rootBoundingBox.Min.Y;
+                _rootBoundingBox.Max.Y += _rootBoundingBox.Max.Y - _rootBoundingBox.Min.Y;
             }
             else
             {
-                m_rootBoundingBox.Min.Y += m_rootBoundingBox.Min.Y - m_rootBoundingBox.Max.Y;
+                _rootBoundingBox.Min.Y += _rootBoundingBox.Min.Y - _rootBoundingBox.Max.Y;
             }
 
             // Adds the new leaves and updates the old and new root.
             for (int i = 0; i < 4; i++)
             {
-                if (oldRootIndex == m_vertices.Count)
+                if (oldRootIndex == _vertices.Count)
                 {
-                    m_vertices.Add(m_vertices[0]);
+                    _vertices.Add(_vertices[0]);
                 }
                 else
                 {
-                    m_vertices.Add(new QuadtreeVertex(-1, 0));
+                    _vertices.Add(new QuadtreeVertex(-1, 0));
                 }
             }
-            m_vertices[0] = newRoot;
+            _vertices[0] = newRoot;
         }
 
         private void AddToRootLeaf(int itemIndex)
         {
-            Vector2 position = m_items[itemIndex].WorldObject.Position;
-            if (m_vertices[0].ChildCount == 0)
+            Vector2 position = _items[itemIndex].WorldObject.Position;
+            if (_vertices[0].ChildCount == 0)
             {
-                m_vertices[0] = new QuadtreeVertex(itemIndex, 1);
-                m_rootBoundingBox.Min = (m_rootBoundingBox.Max = position);
+                _vertices[0] = new QuadtreeVertex(itemIndex, 1);
+                _rootBoundingBox.Min = (_rootBoundingBox.Max = position);
             }
             else
             {
-                var item = m_items[itemIndex];
-                item.Next = m_vertices[0].FirstChildIndex;
-                m_items[itemIndex] = item;
-                m_vertices[0] = new QuadtreeVertex(itemIndex, m_vertices[0].ChildCount + 1);
-                IncludeInBoundingBox(ref m_rootBoundingBox, position);
+                var item = _items[itemIndex];
+                item.Next = _vertices[0].FirstChildIndex;
+                _items[itemIndex] = item;
+                _vertices[0] = new QuadtreeVertex(itemIndex, _vertices[0].ChildCount + 1);
+                IncludeInBoundingBox(ref _rootBoundingBox, position);
             }
         }
 
         private void AddToLeaf(int leafIndex, int itemIndex)
         {
             int next;
-            if (m_vertices[leafIndex].ChildCount == 0)
+            if (_vertices[leafIndex].ChildCount == 0)
             {
                 next = -1;
-                m_vertices[leafIndex] = new QuadtreeVertex(itemIndex, 1);
+                _vertices[leafIndex] = new QuadtreeVertex(itemIndex, 1);
             }
             else
             {
-                next = m_vertices[leafIndex].FirstChildIndex;
-                m_vertices[leafIndex] = new QuadtreeVertex(itemIndex, m_vertices[leafIndex].ChildCount + 1);
+                next = _vertices[leafIndex].FirstChildIndex;
+                _vertices[leafIndex] = new QuadtreeVertex(itemIndex, _vertices[leafIndex].ChildCount + 1);
             }
-            m_items[itemIndex] = new QuadtreeItem<IWorldObject>(m_items[itemIndex].WorldObject, next);
+            _items[itemIndex] = new QuadtreeItem<IWorldObject>(_items[itemIndex].WorldObject, next);
         }
 
         private void SplitLeaf(int leafIndex, BoundingBox2 leafBounds)
         {
             // Splits the leaf vertex by turning it into a branch and adding four new leaves.
-            var oldLeaf = m_vertices[leafIndex];
-            m_vertices[leafIndex] = new QuadtreeVertex(m_vertices.Count, -1);
-            m_vertices.Add(new QuadtreeVertex(-1, 0));
-            m_vertices.Add(new QuadtreeVertex(-1, 0));
-            m_vertices.Add(new QuadtreeVertex(-1, 0));
-            m_vertices.Add(new QuadtreeVertex(-1, 0));
+            var oldLeaf = _vertices[leafIndex];
+            _vertices[leafIndex] = new QuadtreeVertex(_vertices.Count, -1);
+            _vertices.Add(new QuadtreeVertex(-1, 0));
+            _vertices.Add(new QuadtreeVertex(-1, 0));
+            _vertices.Add(new QuadtreeVertex(-1, 0));
+            _vertices.Add(new QuadtreeVertex(-1, 0));
 
             // Distributes the existing items over the new leaves.
             var center = leafBounds.Center;
             int next = oldLeaf.FirstChildIndex;
             while (next != -1)
             {
-                var item = m_items[next];
+                var item = _items[next];
                 int newLeafIndex = FindNextVertex(leafIndex, center, item.WorldObject.Position);
                 AddToLeaf(newLeafIndex, next);
                 next = item.Next;
@@ -280,7 +280,7 @@ namespace Quadtree
 
         private int FindNextVertex(int vertexIndex, Vector2 boundsCenter, Vector2 position)
         {
-            vertexIndex = m_vertices[vertexIndex].FirstChildIndex;
+            vertexIndex = _vertices[vertexIndex].FirstChildIndex;
             if (position.X < boundsCenter.X)
             {
                 vertexIndex++;
@@ -295,11 +295,11 @@ namespace Quadtree
         private (int leafIndex, int depth, BoundingBox2 bounds) FindLeaf(int vertexIndex, BoundingBox2 bounds,
             int depth, Vector2 position)
         {
-            while (m_vertices[vertexIndex].ChildCount == -1)
+            while (_vertices[vertexIndex].ChildCount == -1)
             {
                 depth++;
                 var center = bounds.Center;
-                vertexIndex = m_vertices[vertexIndex].FirstChildIndex;
+                vertexIndex = _vertices[vertexIndex].FirstChildIndex;
                 if (position.X < center.X)
                 {
                     vertexIndex++;
@@ -328,7 +328,7 @@ namespace Quadtree
             switch (inflatedBox.Intersects(vertexBounds))
             {
                 case IntersectionType.Contains:
-                    if (m_vertices[vertexIndex].ChildCount == -1)
+                    if (_vertices[vertexIndex].ChildCount == -1)
                     {
                         // Found contained vertex, appends items of all child vertices.
                         QueryAppendContainedItems(vertexIndex, box, resultList);
@@ -340,7 +340,7 @@ namespace Quadtree
                     }
                     break;
                 case IntersectionType.Intersects:
-                    if (m_vertices[vertexIndex].ChildCount == -1)
+                    if (_vertices[vertexIndex].ChildCount == -1)
                     {
                         // Branches the query.
                         stack.Push(new QuadtreeQuery(vertexIndex, vertexBounds));
@@ -361,10 +361,10 @@ namespace Quadtree
             while (_vertexStack.Count > 0)
             {
                 int current = _vertexStack.Pop();
-                if (m_vertices[current].ChildCount == -1)
+                if (_vertices[current].ChildCount == -1)
                 {
                     // Branches into all vertices until leaves are found.
-                    int childIndex = m_vertices[current].FirstChildIndex;
+                    int childIndex = _vertices[current].FirstChildIndex;
                     _vertexStack.Push(childIndex++);
                     _vertexStack.Push(childIndex++);
                     _vertexStack.Push(childIndex++);
@@ -380,41 +380,41 @@ namespace Quadtree
 
         private void QueryAppendContainedLeafItems(int vertexIndex, BoundingBox2 box, List<IWorldObject> resultList)
         {
-            int index = m_vertices[vertexIndex].FirstChildIndex;
+            int index = _vertices[vertexIndex].FirstChildIndex;
             while (index != -1)
             {
-                IWorldObject obj = m_items[index].WorldObject;
+                IWorldObject obj = _items[index].WorldObject;
                 if (box.Intersects(obj.BoundingBox) != IntersectionType.Disjoint)
                 {
                     resultList.Add(obj);
                 }
-                index = m_items[index].Next;
+                index = _items[index].Next;
             }
         }
 
         /// <summary>
         /// Removes the found item from the item list. Since the list is being reordered for fast removal, the reference
-        /// to the relocated item has to be updated because its list index changes from "m_items.Count - 1" to "index".
+        /// to the relocated item has to be updated because its list index changes from "_items.Count - 1" to "index".
         /// </summary>
         /// <param name="index">Index of the item to be removed.</param>
         private void RemoveFromItems(int index)
         {
-            m_items.RemoveUnorderedAt(index);
-            if (index != m_items.Count)
+            _items.RemoveUnorderedAt(index);
+            if (index != _items.Count)
             {
-                (int leafIndex, _, _) = FindLeaf(0, m_rootBoundingBox, 0, m_items[index].WorldObject.Position);
-                int current = m_vertices[leafIndex].FirstChildIndex;
-                if (current == m_items.Count)
+                (int leafIndex, _, _) = FindLeaf(0, _rootBoundingBox, 0, _items[index].WorldObject.Position);
+                int current = _vertices[leafIndex].FirstChildIndex;
+                if (current == _items.Count)
                 {
-                    m_vertices[leafIndex] = new QuadtreeVertex(index, m_vertices[leafIndex].ChildCount);
+                    _vertices[leafIndex] = new QuadtreeVertex(index, _vertices[leafIndex].ChildCount);
                 }
                 else
                 {
-                    while (m_items[current].Next != m_items.Count)
+                    while (_items[current].Next != _items.Count)
                     {
-                        current = m_items[current].Next;
+                        current = _items[current].Next;
                     }
-                    m_items[current] = new QuadtreeItem<IWorldObject>(m_items[current].WorldObject, index);
+                    _items[current] = new QuadtreeItem<IWorldObject>(_items[current].WorldObject, index);
                 }
             }
         }