protected int Hit(IUnit enemy)
        {
            int r = 0;

            if (Unit.Param.Contains("A"))
            {
                r = 1;
                Print("(автопопадание)", 0);
            }
            else
            {
                if (Unit.WeaponSkill == enemy.WeaponSkill)
                {
                    if (check_k("ws", Unit.Param, 4, 1) != 0) { r = 1; }
                }
                if (Unit.WeaponSkill > enemy.WeaponSkill)
                {
                    if (check_k("ws", Unit.Param, 3, 1) != 0) { r = 1; }
                }
                if (Unit.WeaponSkill < enemy.WeaponSkill)
                {
                    if ((Unit.WeaponSkill * 2) < enemy.WeaponSkill)
                    {
                        if (check_k("ws", Unit.Param, 5, 1) != 0) { r = 1; }
                    }
                    else
                    {
                        if (check_k("ws", Unit.Param, 4, 1) != 0) { r = 1; }
                    }
                }
            }
            return r;
        }

 /// <summary>
 /// Constructs a prime meridian.
 /// </summary>
 /// <param name="name">The name of the prime meridian.</param>
 /// <param name="longitude">The longitude location of the meridian.</param>
 /// <param name="angularUnit">The angular unit of the longitude value.</param>
 /// <param name="authority">The authority.</param>
 public OgcPrimeMeridian(string name, double longitude, IUnit angularUnit, IAuthorityTag authority = null)
     : base(name, authority)
 {
     Contract.Requires(name != null);
     Longitude = longitude;
     Unit = angularUnit ?? OgcAngularUnit.DefaultDegrees;
 }

 public void Select(IUnit unit)
 {
     if(SelectedUnit == unit)
         return;
     SelectedUnit = unit;
     FireUnitEvent(unit, SelectedUnitChanged);
 }

        public override LanguageDigit ConvertToString(decimal number, IUnit unit)
        {
            CheckNumber(number);
            

            if (number <= uint.MaxValue)
            {
                return ConvertToString((uint)number, unit);
            }
            
            if (number <= ulong.MaxValue)
            {
                return ConvertToString((ulong)number, unit);
            }
            


            decimal div1000 = Math.Floor(number / 1000);

            HightDigitClassesToString(div1000, 0, convertedNumber);

            DigitClassToString((uint)(number - div1000 * 1000), unit, convertedNumber);


            return this;
        }

        protected int Wound(IUnit enemy)
        {
            int r = 0;

            int a_s = Unit.Strength;
            if (Unit.Param.Contains("B")) { a_s += 2; }

            if (a_s == enemy.Resistance)
            {
                if (check_k("s", Unit.Param, 4, 1) != 0) { r = 1; }
            }
            else if (a_s == (enemy.Resistance + 1))
            {
                if (check_k("s", Unit.Param, 3, 1) != 0) { r = 1; }
            }
            else if (a_s > (enemy.Resistance + 1))
            {
                if (check_k("s", Unit.Param, 2, 1) != 0) { r = 1; }
            }
            else if ((a_s + 1) == enemy.Resistance)
            {
                if (check_k("s", Unit.Param, 5, 1) != 0) { r = 1; }
            }
            else if ((a_s + 2) == enemy.Resistance)
            {
                if (check_k("s", Unit.Param, 6, 1) != 0) { r = 1; }
            }
            else if ((a_s + 2) < enemy.Resistance)
            {
                r = 0;
            }

            return r;
        }

        public void MoveUnit(int x, int y, IUnit glad)
        {
            if (IsOutOfBounds(x, y))
            {
                Text.WriteLine("");
                Text.ColorWriteLine("Cant move there!", ConsoleColor.DarkRed);
                Thread.Sleep(2000);
                return;
            }

            var unitOnTile = GetTile(x, y);

            if (unitOnTile == null)
            {
                _map[glad.CurrentTile.x, glad.CurrentTile.y] = null;
                glad.CurrentTile.y = y;
                glad.CurrentTile.x = x;
                _map[x, y] = (Tile)glad.CurrentTile;
                return;
            }

            IUnit target = GetTile(x, y).OccupyingUnit;
            (glad as Gladiator).Target = target;
            Program.GameState = GameState.Interacting;
        }

        public void Init()
        {
            motionSimulation = new ThreadSimulationProxy(new Simulation());

            //var npc = new NPC() { ID = "Villain" };
            //motionSimulation.Insert(npc);
            //unit1 = new ThreadUnitProxy(new Unit { ID = "Unit1" }, motionSimulation);
            var us = new Simulation().CreateUnit();
            ((Unit)us).ID = "Unit1";

            unit1 = motionSimulation.CreateUnit(us);
            unit1.IntersectsUnit += new EventHandler<IObjectArgs<IUnit>>(unit1_IntersectsUnit);
            //unit1.IntersectsUnit -= new EventHandler<IObjectArgs<IUnit>>(unit1_IntersectsUnit);
            //unit1.IntersectsUnit += (sender, unit) =>
            //{
            //    DebugOutput("UNITS INTERSECTED");
            //};
            //unit1.IntersectsUnit -= (sender, unit) =>
            //{
            //    DebugOutput("UNITS INTERSECTED");
            //};
            motionSimulation.Insert(unit1);

            //var projectile = new Projectile();
            //projectile.HitsObject += new Action<Object>((o) =>
            //{
            //    DebugOutput("Projectile hit " + ((Unit)o).ID);
            //});
            //motionSimulation.Insert(projectile);
        }

        private void ProcessBattle(IUnit currentUnit, IEnumerable<IUnit> targets, IList<IUnit> killedUnits)
        {
            foreach (var target in targets)
            {
                var attack = currentUnit.CombatHandler.GenerateAttack();

                int healthDamage = attack.Damage - target.DefensePoints;
                if (healthDamage > 0)
                {
                    target.HealthPoints -= healthDamage;

                    this.Engine.OutputWriter.Write(string.Format(
                        "{0} cast {1} on {2} for {3} damage",
                        currentUnit.Name,
                        attack.GetType().Name,
                        target.Name,
                        healthDamage));

                    if (target.HealthPoints < 0)
                    {
                        target.HealthPoints = 0;

                        this.Engine.OutputWriter.Write(string.Format(
                            "{0} has killed {1}",
                            currentUnit.Name,
                            target.Name));

                        killedUnits.Add(target);
                    }
                }
            }
        }

        /// <summary>
        /// Converts the distance into area
        /// </summary>
        /// <param name="d1"></param>
        /// <param name="d2"></param>
        /// <returns></returns>
        public static IUnit<IArea> Times(this IUnit<IDistance> d1, IUnit<IDistance> d2)
        {
            var f1 = d1.In().Feet;
            var f2 = d2.In().Feet;

            return (f1.Quantity * f2.Quantity).Square().Feet;
        }

 public override IEnumerable<IUnitConversion<double>> GetConversionsTo(IUnit to)
 {
     Contract.Ensures(Contract.Result<IEnumerable<IUnitConversion<double>>>() != null);
     return AreUnitsMatching(_singleUnit, to)
         ? new[] { new UnitUnityConversion(_singleUnit, to) }
         : Enumerable.Empty<IUnitConversion<double>>();
 }

 public SingleUnityUnitConversionMap(IUnit unit, IEqualityComparer<IUnit> unitEqualityComparer = null)
     : base(unitEqualityComparer)
 {
     if (null == unit) throw new ArgumentNullException("unit");
     Contract.EndContractBlock();
     _singleUnit = unit;
 }

        /// <summary>
        /// Получить пропись числа с согласованной единицей измерения.
        /// </summary>
        /// <param name="doubleDigit"> 
        /// CDigit должно быть целым, неотрицательным, не большим <see cref="MaxDouble"/>. 
        /// </param>
        /// <param name="unit"></param>
        /// <param name="result"> Сюда записывается результат. </param>
        /// <exception cref="ArgumentException">
        /// Если doubleDigit меньше нуля, не целое или больше <see cref="MaxDouble"/>. 
        /// </exception>
        /// <returns> <paramref name="result"/> </returns>
        /// <remarks>
        /// float по умолчанию преобразуется к double, поэтому нет перегрузки для float.
        /// В результате ошибок округления возможно расхождение цифр прописи и
        /// строки, выдаваемой double.ToString ("R"), начиная с 17 значащей цифры.
        /// </remarks>
        public static StringBuilder ConvertToString(double doubleDigit, IUnit unit, StringBuilder result)
        {
            string error = CheckDigit(doubleDigit);
            if (error != null) throw new ArgumentException(error, "число");

            if (doubleDigit <= uint.MaxValue)
            {
                ConvertToString((uint)doubleDigit, unit, result);
            }
            else if (doubleDigit <= ulong.MaxValue)
            {
                // SumConvertToString с ulong выполняется в среднем в 2 раза быстрее.
                ConvertToString((ulong)doubleDigit, unit, result);
            }
            else
            {
                MyStringBuilder mySb = new MyStringBuilder(result);

                double div1000 = Math.Floor(doubleDigit / 1000);
                HightDigitClassesToString(div1000, 0, mySb);
                DigitClassToString((uint)(doubleDigit - div1000 * 1000), unit, mySb);
            }

            return result;
        }

        public override int Attack(IUnit enemy)
        {
            int r = 0;

            if ((Unit.LifePoints > 0) && (enemy.LifePoints > 0))
            {
                Print("\n" + Unit.Name + " --> попадание", 0);
                if (Hit(enemy) != 0)
                {
                    Print(" --> ранение ", 0);
                    if (Wound(enemy) != 0)
                    {
                        Print(" --> броня ", 0);
                        if (NotAs(Unit) != 0)
                        {
                            if (enemy.Ward != 0)
                            {
                                Print(" --> особая защита ", 0);
                            }
                            if (not_ward(enemy) != 0)
                            {
                                Print(" --> " + enemy.Name + " РАНЕН", 2);
                                r = 1;
                            }
                        }
                    }
                }
                if (r == 0)
                {
                    Print(" --> не получилось", 1);
                }
            }
            return r;
        }

 public Spell(IUnit unit, int energyCost, int damage)
 {
     this.Unit = unit;
     this.Targets = targets;
     this.Damage = damage;
     this.EnergyCost = energyCost;
 }

 /// <summary>
 /// value is on line between units and on the dist form unit1
 /// </summary>
 /// <param name="unit1">first unit</param>
 /// <param name="unit2">second unit</param>
 /// <param name="Dist">distance from unit1</param>
 public RelativeVector(IUnit unit1, IUnit unit2, float Dist)
 {
     relativeUnit1 = unit1;
     relativeUnit2 = unit2;
     dist = Dist;
     mode = Modes.BetweenUnitsNearOne;
 }

 private void ChangeUnitLocation(IPath pathToTheTargetPlanet, IUnit unitToTeleport, ILocation targetLocation)
 {
     pathToTheTargetPlanet.TargetLocation.Planet.Units.Add(unitToTeleport);
     unitToTeleport.CurrentLocation.Planet.Units.Remove(unitToTeleport);
     unitToTeleport.PreviousLocation = unitToTeleport.CurrentLocation;
     unitToTeleport.CurrentLocation = targetLocation;
 }

        public IUnit CreateUnit(IUnit unitType)
        {
            var spawnedUnit = unitType.Spawn();
            this.UnitsManufactured += 1;

            return spawnedUnit;
        }

 /// <summary>
 /// Loads a unit into the host
 /// </summary>
 /// <param name="unit">Unit to load</param>
 public void LoadUnit( IUnit unit )
 {
     Arguments.CheckNotNull( unit, "unit" );
     Log.Info( "Loading unit " + unit);
     unit.Initialize( m_Environment );
     m_Units.Add( unit );
 }

 /// <summary>
 /// Copy constructor
 /// </summary>
 /// <param name="source">The unit to copy</param>
 public Unit(IUnit source)
 {
     Description = source.Description;
     ID = source.ID;
     ConversionFactorToSI = source.ConversionFactorToSI;
     OffSetToSI = source.OffSetToSI;
 }

 public Intracommunicator localComm(IUnit caller)
 {
     Intracommunicator _localComm;
        //_localComm = (Intracommunicator)Communicator.world.Create(Communicator.world.Group.IncludeOnly(caller.Ranks));
        _localComm = (Intracommunicator)this.WorldComm.Create(this.WorldComm.Group.IncludeOnly(caller.Ranks));
        return _localComm;
 }