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

 // called by engine
 internal 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;
 }

 // 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;
 }

 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);
 }

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

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

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

 public virtual void BeginTurnBased(Critter first_turn_crit)
 {
     Map_BeginTurnBased(thisptr, first_turn_crit.ThisPtr);
 }

 public virtual void RunFlyEffect(ushort pid, Critter from_cr, Critter to_cr, ushort from_hx, ushort from_hy, ushort to_hx, ushort to_hy)
 {
     Map_RunFlyEffect(thisptr, pid, (IntPtr)from_cr, (IntPtr)to_cr, from_hx, from_hy, to_hx, to_hy);
 }

 public virtual void EventOutCritter(Critter cr)
 {
     Map_EventOutCritter(thisptr, cr.ThisPtr);
 }

 public CritterBarterEventArgs(Critter cr, Critter cr_barter, bool attach, uint barter_count)
     : base(cr)
 {
     this.CrBarter = cr_barter;
     this.Attach = attach;
     this.BarterCount = barter_count;
 }

 public CritterAttackEventArgs(Critter cr, Critter target)
     : base(cr)
 {
     this.Target = target;
 }

 public CritterAttackedEventArgs(Critter cr, Critter attacker)
     : base(cr)
 {
     this.Attacker = attacker;
 }

 // called by engine
 bool RaiseUseSkillOnMe(Critter who_use, int skill)
 {
     if (UseSkillOnMe != null)
     {
         var e = new CritterUseSkillOnMeEventArgs(this, who_use, skill);
         UseSkillOnMe(this, e);
         return e.Prevent;
     }
     return false;
 }

 public CritterGlobalInviteEventArgs(Critter cr, Item car, uint encounter_descriptor, int combat_mode)
     : base(cr)
 {
     this.Car = car;
     this.EncounterDescriptor = encounter_descriptor;
     this.CombatMode = combat_mode;
 }

 public CritterGlobalProcessEventArgs(Critter cr, GlobalProcessType type, Item car)
     : base(cr)
 {
     this.Type = type;
     this.Car = car;
 }

 public CritterChangeItemOnMapEventArgs(Critter cr, Item item)
     : base(cr)
 {
     this.Item = item;
 }

 public virtual uint GetPathLength(Critter cr, ushort to_hx, ushort to_hy, uint cut)
 {
     return Map_GetPathLengthCr(thisptr, cr.ThisPtr, to_hx, to_hy, cut);
 }

 public CritterDeadEventArgs(Critter cr, Critter killer)
     : base(cr)
 {
     this.Killer = killer;
 }

 public virtual bool VerifyTrigger(Critter cr, ushort hx, ushort hy, Direction dir)
 {
     return Map_VerifyTrigger(thisptr, cr.ThisPtr, hx, hy, (byte)dir);
 }