public ControlNode(Vector2i pos, float[,] map, Vector2 position, float size)
                : base(position)
            {
                Active = map[pos.x, pos.y];

                if (pos.x == map.GetLength(0))
                {
                    Right = new Node(position + Vector2.right * size * 0.5f);
                }
                else
                {
                    Right = new Node(position + Vector2.right * size * 0.5f);
                }

                if (pos.y == map.GetLength(1))
                {
                    Up = new Node(position + Vector2.up * size * 0.5f);
                }
                else
                {
                    Up = new Node(position + Vector2.up * size * 0.5f);
                }

                //float right = pos.x <  ? map[pos.x + 1, pos.y] : Active;
                //float up = map[pos.x, pos.y + 1];
            }

    private static Vector2i? GetActualPosition(Vector2 position)
    {
        NavigationField navigationField = NavigationField.Instance;
        Vector2i pos = Vector2i.FromVector2Round(position);
        if (!navigationField.fieldSize.ContainsAsSize(pos))
        {
            return null;
        }

        if (!float.IsPositiveInfinity(navigationField.Costs[pos.x, pos.y]))
        {
            return pos;
        }

        // Try to find a nice neighbour...
        for (int y = -1; y <= 1; y++)
        {
            for (int x = -1; x <= 1; x++)
            {
                Vector2i test = new Vector2i(pos.x + x, pos.y + y);
                if (!float.IsPositiveInfinity(navigationField.GetCost(test)))
                {
                    return test;
                }
            }
        }

        return null;
    }

 public Job_PlantSeed(Vector2i plantPos, VoxelTypes seedType, IGrowPattern growPattern)
     : base(Labors.Farm, "Plant Seed", "Planting seed")
 {
     PlantPos = plantPos;
     SeedType = seedType;
     GrowPattern = growPattern;
 }

        public static bool OnMouseButton(Controls.Control hoveredControl, int x, int y, bool down)
        {
            if (!down)
            {
                m_LastPressedControl = null;

                // Not carrying anything, allow normal actions
                if (CurrentPackage == null)
                    return false;

                // We were carrying something, drop it.
                onDrop(x, y);
                return true;
            }

            if (hoveredControl == null)
                return false;
            if (!hoveredControl.DragAndDrop_Draggable())
                return false;

            // Store the last clicked on control. Don't do anything yet,
            // we'll check it in OnMouseMoved, and if it moves further than
            // x pixels with the mouse down, we'll start to drag.
            m_LastPressedPos = new Vector2i(x, y);
            m_LastPressedControl = hoveredControl;

            return false;
        }

        public Cannon(Direction2D direction, Vector2i index)
        {
            _direction = direction;
            _worldIndex = index;

            _readOnlyBullets = new ReadOnlyCollection<Bullet>(_bullets);
        }

 public override void SetField(Vector2i vect, char value)
 {
     if (IsEntryPointInTheSize(vect))
     {
         VarField[vect.X, vect.Y] = value;
     }
 }

 public static Vector2i Next(this Random random, Vector2i min, Vector2i max)
 {
     return new Vector2i(
         random.Next(min.X, max.X + 1),
         random.Next(min.Y, max.Y + 1)
     );
 }

 public void SendVector(Vector2i vect)
 {
     if (!(Player is Player.NetworkPlayer))
     {
         client.Send(string.Format("UniTTT!Vector:{0}", vect.ToString()));
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="FreezingArcher.Messaging.ItemCollectedMessage"/> class.
 /// </summary>
 /// <param name="item">Item.</param>
 /// <param name="inventoryPosition">Inventory position.</param>
 /// <param name="entity">Entity.</param>
 public ItemCollectedMessage(Entity entity, ItemComponent item, Vector2i inventoryPosition)
 {
     Entity = entity;
     Item = item;
     InventoryPosition = inventoryPosition;
     MessageId = (int) Messaging.MessageId.ItemCollected;
 }

        public double DistanceEstimate(Vector2i a, Vector2i b)
        {
            if (UseManhattanMetric)
                return Math.Abs(b.X - a.X) + Math.Abs(b.Y - a.Y);

            return Utils.Distance(new Vector2f(a.X, a.Y), new Vector2f(b.X, b.Y));
        }

 public Exit(Vector2i _pos)
     : base(_pos)
 {
     CurrentTex = "exit";
     Movable = false;
     Open = false;
 }

 public void Setup(RL.Map _map, int[] _dir)
 {
     map = _map;
     directions = _dir;
     lineRenderers = new GameObject[directions.Length];
     for (int i = 0; i < directions.Length; i++) {
         lineRenderers [i] = new GameObject ();
         lineRenderers [i].transform.parent = transform;
         lineRenderers [i].transform.position = transform.position;
         LineRenderer lr = lineRenderers [i].AddComponent<LineRenderer> ();
         lr.renderer.sortingOrder = 2;
         lr.renderer.sortingLayerName = "Default";
         lr.SetColors(new Color(74/255f,63/255f,148/255f, 0.5f), new Color(113/255f,138/255f,145/255f, 0.5f));
         lr.SetWidth (0.05f, 0.05f);
         lr.material = (Material)Resources.Load ("trapParticle");
         lr.useWorldSpace = false;
         // move out on the direction until we hit a wall, this is our endpoint
         Vector2i ndir = new Vector2i (RL.Map.nDir[directions[i],0], RL.Map.nDir[directions[i],1]);
         Vector2i np = GetComponent<RLCharacter>().positionI;
         int distanceCount = 1;
         np += ndir;
         while (map.IsOpenTile (np.x, np.y)) {
             np += ndir;
         }
     //			np -= ndir*0.5f;
         lr.SetPosition (0, Vector3.zero);
         lr.SetPosition (1, new Vector3(np.x-ndir.x*0.5f, np.y-ndir.y*0.5f, 0)-transform.position);
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="FreezingArcher.Core.Window"/> class.
        /// </summary>
        /// <param name="size">Windowed size.</param>
        /// <param name="resolution">Resolution of the framebuffer.</param>
        /// <param name="title">Title.</param>
        public Window (Vector2i size, Vector2i resolution, string title)
        {
            Logger.Log.AddLogEntry (LogLevel.Info, ClassName, "Creating new window '{0}'", title);
	    MSize = size;
	    MResolution = resolution;
	    MTitle = title;
        }

 public static void Stop(BHEntity mEntity, Vector2i mDirection, Rectangle mBounds, int mBoundsOffset)
 {
     if (mDirection.X == -1) mEntity.Position = new Vector2i(mBounds.X + mBoundsOffset, mEntity.Position.Y);
     if (mDirection.X == 1) mEntity.Position = new Vector2i(mBounds.X + mBounds.Width - mBoundsOffset, mEntity.Position.Y);
     if (mDirection.Y == -1) mEntity.Position = new Vector2i(mEntity.Position.X, mBounds.Y + mBoundsOffset);
     if (mDirection.Y == 1) mEntity.Position = new Vector2i(mEntity.Position.X, mBounds.Y - mBoundsOffset + mBounds.Height);
 }

        public override bool Update(Vector2i mouseS, IMapManager currentMap)
        {
            if (currentMap == null) return false;

            spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSpriteKey);

            mouseScreen = mouseS;
            mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);

            var bounds = spriteToDraw.GetLocalBounds();
            var spriteSize = CluwneLib.PixelToTile(new Vector2f(bounds.Width, bounds.Height));
            var spriteRectWorld = new FloatRect(mouseWorld.X - (spriteSize.X / 2f),
                                                 mouseWorld.Y - (spriteSize.Y / 2f),
                                                 spriteSize.X, spriteSize.Y);

            if (pManager.CurrentPermission.IsTile)
                return false;

            if (pManager.CollisionManager.IsColliding(spriteRectWorld))
                return false;

            //if (currentMap.IsSolidTile(mouseWorld)) return false;

            var rangeSquared = pManager.CurrentPermission.Range * pManager.CurrentPermission.Range;
            if (rangeSquared > 0)
                if (
                    (pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
                         .Position - mouseWorld).LengthSquared() > rangeSquared) return false;

            currentTile = currentMap.GetTileRef(mouseWorld);

            return true;
        }

 public Sprite(SpriteSheet spriteSheet, string name, Vector2i size, Box2 coordinates)
 {
     SpriteSheet = spriteSheet;
     Name = name;
     Size = size;
     Coordinates = coordinates;
 }

        public ScrollableContainer(string uniqueName, Vector2i size, IResourceManager resourceManager)
        {
            _resourceManager = resourceManager;

            Size = size;

            //if (RenderTargetCache.Targets.Contains(uniqueName))
            //    //Now this is an ugly hack to work around duplicate RenderImages. Have to fix this later.
            //    uniqueName = uniqueName + Guid.NewGuid();

            clippingRI = new RenderImage(uniqueName,(uint)Size.X,(uint) Size.Y);

            //clippingRI.SourceBlend = AlphaBlendOperation.SourceAlpha;
            //clippingRI.DestinationBlend = AlphaBlendOperation.InverseSourceAlpha;
            //clippingRI.SourceBlendAlpha = AlphaBlendOperation.SourceAlpha;
            //clippingRI.DestinationBlendAlpha = AlphaBlendOperation.InverseSourceAlpha;
            clippingRI.BlendSettings.ColorSrcFactor = BlendMode.Factor.SrcAlpha;
            clippingRI.BlendSettings.ColorDstFactor = BlendMode.Factor.OneMinusSrcAlpha;
            clippingRI.BlendSettings.AlphaSrcFactor = BlendMode.Factor.SrcAlpha;
            clippingRI.BlendSettings.AlphaDstFactor = BlendMode.Factor.OneMinusSrcAlpha;

            scrollbarH = new Scrollbar(true, _resourceManager);
            scrollbarV = new Scrollbar(false, _resourceManager);
            scrollbarV.size = Size.Y;

            scrollbarH.Update(0);
            scrollbarV.Update(0);

            Update(0);
        }

 public BlockInfo(Vector2i position, BlockType type, float height, Vector3 normal)
 {
     Position = position;
     Type = type;
     Height = height;
     Normal = normal;
 }

        protected override BlockType GenerateBlock(Vector2i worldPosition, Vector2i turbulence, Vector3 normal, ZoneRatio influence)
        {
            if (Vector3.Angle(Vector3.up, normal) > 65)
                return BlockType.Rock;

            return base.GenerateBlock(worldPosition, turbulence, normal, influence);
        }

    /// <summary>
    /// Returns the indices of the squares on a grid that intersect a line 
    /// beginning at vector "start" and ending at vector "end".  Right now 
    /// uses Bresenham's algorithm which may be a bad choice.
    /// </summary>
    /// <param name="start"></param>
    /// <param name="end"></param>
    /// <returns></returns>
    public IEnumerable<Vector2i> GetIntermediatePoints(Vector2i start, Vector2i end)
    {
        // http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
        var x0 = start.X;
        var x1 = end.X;
        var y0 = start.Y;
        var y1 = end.Y;
        var dx = Math.Abs(x1 - x0);
        var dy = Math.Abs(y0 - y1);

        var sx = (x0 < x1)? 1 : -1;
        var sy = (y0 < y1)? 1 : -1;
        var err = dx - dy;

        while (x0 != x1 || y0 != y1)
        {
            yield return new Vector2i(x0, y0);
            var e2 = err * 2;
            if (e2 > -dy)
            {
                err -= dy;
                x0 += sx;
            }

            if (e2 < dx)
            {
                err += dx;
                y0 += sy;
            }
        }
    }