// Methods
 internal LinearGradient(string prefix, string localname, string ns, SvgDocument doc)
     : base(prefix, localname, ns, doc)
 {
     this.x1 = 0f;
     this.y1 = 0f;
     this.x2 = 1f;
     this.y2 = 0f;
     this.gradientTransform = new Transf();
     this.gradientUnit = Units.ObjectBoundingBox;
     this.spreadMethod = SpreadMethods.Pad;
     this.boundsPath = new GraphicsPath();
     this.boundrect = RectangleF.Empty;
     this.stops = new SvgElementCollection();
     this.gradientstart = PointF.Empty;
     this.gradientend = PointF.Empty;
     this.rotatepoint = PointF.Empty;
     this.translatepoint = PointF.Empty;
     this.scalePoint = PointF.Empty;
     this.boundsPoints = new PointF[0];
     this.ratiomatrix = new Matrix();
     this.brush = null;
     this.coord = new Matrix();
     this.gradientpath = new GraphicsPath();
     this.pen = null;
     this.GraphMatrix = new Matrix();
 }

 public BackendlessGeoQuery( double NWLat, double NWLon, double SELat, double SWLon, Units units, List<string> categories )
 {
   ClusterGridSize = CLUSTER_SIZE_DEFAULT_VALUE;
   SearchRectangle = new[] { NWLat, NWLon, SELat, SWLon };
   Units = units;
   Categories = categories;
 }

 public virtual void OnUnitDead(Units unitDead)
 {
     if (inRangeUnits.Contains(unitDead))
     {
         inRangeUnits.Remove(unitDead);
     }
 }

        public int GetDistance(Address origin, Address destination, Mode mode, Units units) {
            if (origin == null || destination == null) {
                return 0;
            }
            var request =
                (HttpWebRequest)
                    WebRequest.Create(
                        new Uri(String.Format(DistanceMatrixUrl,
                            new object[] {
                                HttpUtility.JavaScriptStringEncode(origin.PostalCode), 
                                HttpUtility.JavaScriptStringEncode(destination.PostalCode), 
                                Enum.GetName(typeof(Mode), mode),
                                Enum.GetName(typeof(Units), units)
                            })));
            var response = (HttpWebResponse) request.GetResponse();
            if (response.StatusCode != HttpStatusCode.OK) return 0;

            using (var streamReader = new StreamReader(response.GetResponseStream())) {
                var result = streamReader.ReadToEnd();
                if (string.IsNullOrEmpty(result)) return 0;
                var jsonObject = JObject.Parse(result);
                var distance = (int)jsonObject.SelectToken("rows[0].elements[0].distance.value");
                return distance / 1000;
            }
        }

        public override void PlaceBuilding(Units.Engineer e)
        {
            this.state = State.Constructing;
            this.constructedBy = e;
            e.constructing = this;
            this.mesh = Game1.GetInstance().map.collisionMap.PlaceBuilding(this.DefineRectangle());
            Game1.GetInstance().IsMouseVisible = true;

            for( int i = 0; i < p.buildings.Count(); i++){
                Building b = p.buildings.ElementAt(i);
                if (b != this)
                {
                    if (b.type != Type.Resources && b.type != Type.Sentry)
                    {
                        if (b.waypoints.Count() > 0)
                        {
                            Point point = b.waypoints.GetLast();
                            PathfindingProcessor.GetInstance().Push(b, point);
                        }
                    }
                }
            }

            if (Game1.GetInstance().IsMultiplayerGame() &&
                     this.p == Game1.CURRENT_PLAYER)
            {
                Synchronizer.GetInstance().QueueBuilding(this);
            }

            p.resources -= Building.GetCost(this.type);
        }

        public UnitsResponse Post(Units request)
        {
            if (request.Unit.Id > 0)
              {
            Bm2s.Data.Common.BLL.Parameter.Unit item = Datas.Instance.DataStorage.Units[request.Unit.Id];
            item.Code = request.Unit.Code;
            item.Description = request.Unit.Description;
            item.EndingDate = request.Unit.EndingDate;
            item.IsCurrency = request.Unit.IsCurrency;
            item.IsPeriod = request.Unit.IsPeriod;
            item.Name = request.Unit.Name;
            item.StartingDate = request.Unit.StartingDate;
            Datas.Instance.DataStorage.Units[request.Unit.Id] = item;
              }
              else
              {
            Bm2s.Data.Common.BLL.Parameter.Unit item = new Data.Common.BLL.Parameter.Unit()
            {
              Code = request.Unit.Code,
              Description = request.Unit.Description,
              EndingDate = request.Unit.EndingDate,
              IsCurrency = request.Unit.IsCurrency,
              IsPeriod = request.Unit.IsPeriod,
              Name = request.Unit.Name,
              StartingDate = request.Unit.StartingDate
            };

            Datas.Instance.DataStorage.Units.Add(item);
            request.Unit.Id = item.Id;
              }

              UnitsResponse response = new UnitsResponse();
              response.Units.Add(request.Unit);
              return response;
        }

 /// <summary>
 /// Променя стойност в речника stats по зададените параметри
 /// </summary>
 /// <param name="unitToSet">В каква мерна единица е зададеното число</param>
 /// <param name="value">Самото число което задаваме</param>
 public void SetStat(Units unitToSet, double value)
 {
     foreach (Units unit in UnitS.Array)
     {
         stats[unit].Value = value * (stats[unitToSet].Modifier / stats[unit].Modifier);
     }
 }

 public BackendlessGeoQuery(double latitude, double longitude, double radius, Units units)
 {
     Latitude = latitude;
       Longitude = longitude;
       Radius = radius;
       Units = units;
       PageSize = 100;
 }

 public SlamEffect(Units.MainCharacter performer)
 {
     AddChild(new SwordStrikeEffect(performer,
            0.3f, 0.47f, new TextureFromFile("Models/Effects/SlamFire1.png"), -10f)
            {
                OrientationRelation = OrientationRelation.Absolute
            });
 }

 public AreaSettings(Units units, float top, float left, float bottom, float right)
 {
     _units = units;
     _top = top;
     _left = left;
     _bottom = bottom;
     _right = right;
 }               

        /// <summary>
        /// Builds marble geometry
        /// </summary>
        private void BuildGeometry( Units.Metres radius )
        {
            DestroyGeometry( );

            Graphics.Draw.StartCache( );
            Graphics.Draw.Sphere( null, Point3.Origin, ( float )radius.ToAstroRenderUnits, 20, 20 );
            m_Geometry = Graphics.Draw.StopCache( );
            m_GeometryRadius = radius;
        }

        public static Amount Convert(Amount amount, Units toUnit)
        {
            var ret = new Amount();
            ret.Unit = toUnit;
            ret.SizeLow = amount.SizeLow.HasValue ? (float?)Convert(amount.SizeLow.Value, amount.Unit, toUnit) : null;
            ret.SizeHigh = Convert(amount.SizeHigh, amount.Unit, toUnit);

            return ret;
        }

        /// <summary>
        /// Calculate the distance between two places.
        /// </summary>
        /// <param name="lat1"></param>
        /// <param name="lon1"></param>
        /// <param name="lat2"></param>
        /// <param name="lon2"></param>
        /// <param name="unit"></param>
        /// <returns></returns>
        public static double DistanceBetweenPlaces(double lat1, double lon1, double lat2, double lon2, Units unit)
        {
            double dlon = Radians(lon2 - lon1);
            double dlat = Radians(lat2 - lat1);

            double a = (Math.Sin(dlat / 2) * Math.Sin(dlat / 2)) + Math.Cos(Radians(lat1)) * Math.Cos(Radians(lat2)) * (Math.Sin(dlon / 2) * Math.Sin(dlon / 2));
            double angle = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
            double distance = (angle * RADIO) * (unit == Units.Miles ? 0.62137 : 1);
            return distance;
        }

        public UnitsResponse Delete(Units request)
        {
            Bm2s.Data.Common.BLL.Parameter.Unit item = Datas.Instance.DataStorage.Units[request.Unit.Id];
              item.EndingDate = DateTime.Now;
              Datas.Instance.DataStorage.Units[item.Id] = item;

              UnitsResponse response = new UnitsResponse();
              response.Units.Add(request.Unit);
              return response;
        }

 public IngredientForm(Guid formId, Guid ingredientId, Units unitType, string displayName, string unitName, int conversionMultiplier, Amount amount)
 {
     this.FormId = formId;
     this.IngredientId = ingredientId;
     this.FormUnitType = unitType;
     this.FormDisplayName = displayName;
     this.FormUnitName = unitName;
     this.ConversionMultiplier = conversionMultiplier;
     this.FormAmount = amount;
 }

 public IngredientForm(Guid formid, Guid ingredientid, Units unittype, string displayname, string unitname, int convmultiplier, Amount amount)
 {
     FormId = formid;
      IngredientId = ingredientid;
      FormUnitType = unittype;
      FormDisplayName = displayname;
      FormUnitName = unitname;
      ConversionMultiplier = convmultiplier;
      FormAmount = amount;
 }

 public double ToSec(double value, Units unit)
 {
     switch (unit)
     {
         case Units.Day:
             return value * 60 * 60 * 24;
         default:
             throw new Exception("Uncorrect cast to SI");
     }
 }

 public double ToKG(double value, Units unit)
 {
     switch (unit)
     {
         case Units.T:
             return value * 1000;
         default:
             throw new Exception("Uncorrect cast to SI");
     }
 }

        public double continuousRotation(double x, Units unit, string indexer)
        {
            if(!continousRotationStrategies.ContainsKey(indexer))
                continousRotationStrategies[indexer] = new ContinuesRotationStrategy(unit);

            var strategy = continousRotationStrategies[indexer];
            strategy.Update(x);

            return strategy.Out;
        }

 /// <summary>
 /// Sets the value and units of the angle.
 /// </summary>
 /// <param name="angularValue">The value for the angle.</param>
 /// <param name="angularUnits">The units for the angle.</param>
 public void setAngle(double angularValue, Units.Angular angularUnits)
 {
     if (angularUnits == Units.Angular.Radians)
     {
         _angularValue = angularValue * radToDeg;
     }
     else
     {
         _angularValue = angularValue;
     }
 }