public UInt16Array ChooseAttackPosition(Critter npc, Critter target, AttackChoice attackChoice)
        {
            var weapon = npc.GetItemById (attackChoice.WeaponId);
            if (weapon == null)
                return null;

            var weaponDistance = weapon.Proto.WeaponMaxDist (attackChoice.WeaponUse);
            var distance = Global.GetDistance (npc, target);

            if (weaponDistance < distance) {
                var direction = Global.GetDirection (npc, target);
                var hexX = npc.HexX;
                var hexY = npc.HexY;

                do {
                    npc.GetMap ().MoveHexByDir (ref hexX, ref hexY, direction, 1);
                } while(!npc.GetMap ().IsHexPassed (hexX, hexY));

                var result = new UInt16Array ();
                result.Add (hexX);
                result.Add (hexY);
                result.Add ((ushort)direction);
                return result;
            }

            return null;
        }

 public GlobalCritterStealingEventArgs(Critter cr, Critter thief, Item item, int count)
 {
     this.Cr = cr;
     this.Thief = thief;
     this.Item = Item;
     this.Count = Count;
 }

        public static void InitAnimalEvil(Critter critter)
        {
            var builder = new CritterBehaviorBuilder (critter);

            builder
                .Do (new CallReinforcements (BlackboardKeys.Attackers))
                .DoSequence ("3% to attack weakest animal from my team - fight over the area")
                    .Do (new AtFixedRate<CritterBlackboard> (Time.RealSecond (10)))
                    .Do (new AtChance<CritterBlackboard> (3))
                    .Do (new FindCritters (Find.Life).Choose (new Weakest ())).If (new SeesCritter ()).If (new IsTeamMember ())
                    .Do (new Attack ())
                .End ()
                .DoSequence ("10% to attack animal of same type from other team")
                    .Do (new AtFixedRate<CritterBlackboard> (Time.RealSecond (10)))
                    .Do (new AtChance<CritterBlackboard> (10))
                    .Do (new FindCritters (Find.Life).Choose (new BT.Random ())).If (new SeesCritter ()).IfNot (new IsTeamMember ())
                    .Do (new Attack ())
                .End ()
                .DoSequence ("Attack every non member and not same type critter")
                    .Do (new FindCritters (Find.Life)).IfNot (new AmAttacking ()).If (new SeesCritter ()).If (new IsTeamMember ()).IfNot (new IsSameType ())
                    .Do (new Attack ())
                .End ()
                .Do (new ProvideReinforcements ()).IfNot (new AmAttacking ());

            Global.RegisterBehaviorTask (builder.MainTask);
        }

 // called by engine
 bool RaiseAttack(Critter cr, Critter target)
 {
     if (Attack != null)
     {
         var e = new ItemAttackEventArgs(this, cr, target);
         Attack(this, e);
         return e.Prevent;
     }
     return false;
 }

 // called by engine
 public bool RaiseUse(Critter cr, Critter on_critter, Item on_item, IntPtr on_scenery)
 {
     if (Use != null)
     {
         var e = new ItemUseEventArgs(this, cr, on_critter, on_item, Scenery.FromNative(on_scenery));
         Use(this, e);
         return e.Prevent;
     }
     return false;
 }

        public static void InitGyro(Critter npc)
        {
            var builder = new CritterBehaviorBuilder(npc);

            builder
                .DoSequence("I am attacked")
                    .Do(new CallReinforcements(BlackboardKeys.Attackers, BlackboardKeys.SeenAttackers, BlackboardKeys.Killers))
            //TODO: maybe run to guard
                .End();

            Global.RegisterBehaviorTask(builder.MainTask);
        }

        public static void InitAnimalGood(Critter critter)
        {
            var builder = new CritterBehaviorBuilder (critter);

            builder
                .Do (new CallReinforcements (BlackboardKeys.Attackers))
                .Do (new ProvideReinforcements ()).IfNot (new AmAttacking ())
                .DoSequence ("Move randomly every 10-20 seconds")
                    .Do (new AtFixedRate<CritterBlackboard> (Time.RealSecond (10), Time.RealSecond (20)))
                    .Do (new MoveRandomly (1, 5))
                .End ();

            Global.RegisterBehaviorTask (builder.MainTask);
        }

        public Critter ChooseNextTarget(Critter npc, Critter currentTarget)
        {
            var enemyStack = new UIntArray ();
            npc.GetEnemyStack (enemyStack);

            for (int i = 0; i < enemyStack.Length; i++) {
                if (enemyStack [i] != 0) {
                    var target = npc.GetMap ().GetCritter (enemyStack [i]);
                    if (target != null)
                        return target;
                }
            }

            return null;
        }

 public static bool AddAttackPlane(this Critter npc, uint priority, Critter target, int minHp)
 {
     NpcPlane plane=Global.CreatePlane();
     plane.Type=PlaneType.Attack;
     plane.Priority=(priority==0?Priorities.Attack:priority);
     plane.Attack_TargId=target.Id;
     plane.Attack_MinHp=minHp;
     plane.Attack_IsGag=false;
     plane.Attack_GagHexX=0;
     plane.Attack_GagHexY=0;
     plane.Attack_LastHexY=target.HexY;
     plane.Attack_LastHexX=target.HexX;
     plane.Run=false;
     return npc.AddPlane(plane);
 }

        /**
         * Init methods for use in Mono
         */
        public static void InitGuard(Critter npc)
        {
            var builder = new CritterBehaviorBuilder(npc);

            builder
                .DoSequence()
                    .Do(new CallReinforcements(BlackboardKeys.Attackers, BlackboardKeys.SeenAttackers, BlackboardKeys.Killers))
                    .Do(new BT.Say(FOnline.Say.NormOnHead, TextMsg.Text, 70140))
                    .Do(new Attack(BlackboardKeys.Attackers))
                .End()
                .DoSelection()
                    .Do(new ProvideReinforcements())
                .End();

            Global.RegisterBehaviorTask(builder.MainTask);
        }

        /**
         * Init methods for use in Mono
         */
        public static void InitGuard(Critter npc)
        {
            var builder = new CritterBehaviorBuilder(npc);

            builder
                .DoSequence()
                    .Do(new CallReinforcements(BlackboardKeys.Attackers, BlackboardKeys.SeenAttackers, BlackboardKeys.Killers))
                    .Do(new Attack(BlackboardKeys.Attackers))
                .End()
                .DoSelection()
                    .Do(new ProvideReinforcements())
                .End()
                .DoSequence()
                    .Do(new Patrol(Entire.Patrol))
                    .Do(new LookAround(3, Time.RealSecond(15)))
                .End();

            Global.RegisterBehaviorTask(builder.MainTask);
        }

        public static void InitCritter1(Critter npc)
        {
            var builder = new CritterBehaviorBuilder(npc);

            builder
                .Do(new TakeDrug(ItemPack.HealingDrugs).If(new IsHurt(70)))
                .DoSequence("Attack and call reinforcements")
                    .Do(new CallReinforcements(BlackboardKeys.Attackers, BlackboardKeys.SeenAttackers, BlackboardKeys.Killers))
                    .Do(new CallReinforcements(VirtualRealityReinforcements, BlackboardKeys.Attackers, BlackboardKeys.Killers))
                    .Do(new Attack(BlackboardKeys.Attackers))
                .End()
                .Do(new ProvideReinforcements()).IfNot(new AmAttacking())
                .Do(new ProvideReinforcements(VirtualRealityReinforcements)).IfNot(new AmAttacking()).If(new SeesCritter())
                .DoSequence("Find player and attack him")
                    .Do(new FindCritters(Find.Life | Find.OnlyPlayers).Choose(new Weakest())).If(new SeesCritter()).IfNot(new AmAttacking())
                    .Do(new Attack())
                .End();

            Global.RegisterBehaviorTask(builder.MainTask);
        }

        /**
         * Init methods for use in Mono
         */
        public static void InitHumanEvil(Critter critter)
        {
            var builder = new CritterBehaviorBuilder (critter);

            builder
                .Do (new CallReinforcements (BlackboardKeys.Attackers))
                .Do (new TakeDrug (ItemPack.HealingDrugs)).If (new IsHurt (70))
                .DoSequence ("20% to find weakest player and attack him instead")
                    .Do (new AtFixedRate<CritterBlackboard> (Time.RealSecond (10)))
                    .Do (new AtChance<CritterBlackboard> (20))
                    .Do (new FindCritters (Find.Life | Find.OnlyPlayers).Choose (new Weakest ())).If (new SeesCritter ()).IfNot (new IsTeamMember ())
                    .Do (new Attack ())
                .End ()
                .DoSequence ("Attack every non member")
                    .Do (new FindCritters (Find.Life)).If (new SeesCritter ()).IfNot (new AmAttacking ()).IfNot (new IsTeamMember ())
                    .Do (new Attack ())
                .End ()
                .Do (new ProvideReinforcements ()).IfNot (new AmAttacking ());

            Global.RegisterBehaviorTask (builder.MainTask);
        }

        public AttackChoice ChooseAttack(Critter npc, Critter target)
        {
            var attackChoice = new AttackChoice ();
            var currentItem = npc.GetItemHand ();
            Item weaponItem = null;

            if (currentItem != null) {
                if (CanBeMyWeapon (npc, currentItem)) {
                    weaponItem = currentItem;
                }
            } else {
                weaponItem = null;
            }

            if (weaponItem == null) {
                return null;
            }
            attackChoice.WeaponId = weaponItem.Id;
            attackChoice.WeaponUse = 0;
            attackChoice.HitLocation = HitLocation.Uncalled;

            return attackChoice;
        }

 // called by engine
 void RaiseTurnBasedProcess(Critter cr, bool begin_turn)
 {
     if (TurnBasedProcess != null)
         TurnBasedProcess (this, new MapTurnBasedProcessEventArgs (this, cr, begin_turn));
 }

 public uint GetVisibleLocations(ushort wx, ushort wy, uint radius, Critter visible_for, LocationArray locations)
 {
     return Global_GetVisibleLocations(wx, wy, radius, visible_for.ThisPtr, (IntPtr)locations);
 }

 // called by engine
 void RaiseCritterDead(Critter cr, Critter killer)
 {
     if (CritterDead != null)
         CritterDead (this, new MapCritterDeadEventArgs (this, cr, killer));
 }

 // called by engine
 void RaiseOutCritter(Critter cr)
 {
     if (OutCritter != null)
         OutCritter (this, new MapInOutCritterEventArgs (this, cr));
 }

 public MapInOutCritterEventArgs(Map map, Critter cr)
     : base(map)
 {
     this.Cr = cr;
 }

 public MapTurnBasedProcessEventArgs(Map map, Critter cr, bool begin_turn)
     : base(map)
 {
     this.Cr = cr;
     this.BeginTurn = begin_turn;
 }