[C# Source Code]Terrarium Farm.

超、凢脫俗 2022-09-29 12:59 134阅读 0赞

using System; 
    using System.Drawing;
    using System.Collections; 
    using System.IO; 
      [assembly: OrganismClass("MyCreature")]        
      [assembly: AuthorInformation("naka", "")]
      [AnimalSkin(AnimalSkinFamilyEnum.Beetle,"mari")]  
      [CarnivoreAttribute(true)]
      [MatureSize(26)]                            
      [MaximumEnergyPoints( 15 )]
      [EatingSpeedPoints( 5 )]
      [AttackDamagePoints( 0 )]
      [DefendDamagePoints( 0 )]
      [MaximumSpeedPoints( 20 )]
      [CamouflagePoints( 0 )]
      [EyesightPoints( 60 )]
    /* NOX 
      [AnimalSkin(AnimalSkinFamilyEnum.Beetle,"XXE40240805")]
      [MatureSize(32)]                            
      [MaximumEnergyPoints( 18 )]
      [EatingSpeedPoints( 5 )]
      [AttackDamagePoints( 20 )]
      [DefendDamagePoints( 0 )]
      [MaximumSpeedPoints( 17 )]
      [CamouflagePoints( 0 )]
      [EyesightPoints( 40 )]
    */
    
    
    
      public class MyCreature : Animal
      {
          private class DistComparer3 : IComparer {
              MyCreature my;
              public DistComparer3(MyCreature my) {
                  this.my = my;
              }
              public int Compare(object a,object b) {
                  if(a==null || b ==null)
                      return 0;
                  int d = my.CellDistanceTo(((OrganismState)a))
                  - my.CellDistanceTo(((OrganismState) b));
                  if(d == 0 && a is AnimalState && b is AnimalState){
                      d=Power((AnimalState)b)-Power((AnimalState)a);
                  }
                  if(d == 0 && a is AnimalState && b is AnimalState){
                      d=((AnimalState)a).Damage-((AnimalState)b).Damage;
                  }
                  return d;
              }
              int Power (AnimalState a){
                  return a.AnimalSpecies.MaximumAttackDamagePerUnitRadius * a.Radius
                  +a.AnimalSpecies.MaximumDefendDamagePerUnitRadius * a.Radius;
              }
          }
          /*
          private class SortableOrganism: IComparable
          {
              public OrganismState organism;
              public double score;
              public SortableOrganism(OrganismState organism, double score)
              {
                  this.organism = organism;
                  this.score = score;
              }
              public virtual int CompareTo(object obj)
              {
                  if (((SortableOrganism) obj).score < score)
                      return (-1);
                  if (((SortableOrganism) obj).score == score)
                      return 0;
                  else
                      return 1;
              }
          }
          */
          Hashtable       Creatures       = new Hashtable();      
          public ArrayList    kyoi        = new ArrayList();    
          public ArrayList    kamo        = new ArrayList();    
          public ArrayList    animal        = new ArrayList();    
          public ArrayList    esa        = new ArrayList();    
          public ArrayList    esa2        = new ArrayList();    
          public ArrayList    Plants        = new ArrayList();    
          public ArrayList    Friends        = new ArrayList();    
          public ArrayList    Dead        = new ArrayList();    
          public ArrayList    AttackAS    = new ArrayList();    
          public ArrayList    FoundAS        = new ArrayList();    
          public ArrayList    AS             = new ArrayList();    
          public Vector lastRunaway;
          public    bool isBlocked;
          Hashtable SeenCreatures = new Hashtable();
          public ArrayList Seenkyoi =new ArrayList();
          private ArrayList RetiredFriends = new ArrayList(); 
          public ArrayList SeenCarnivores = new ArrayList();
          private bool isCarnivoreNear = false;
          ArrayList    Attackers    = new ArrayList();
          bool isclose;
          bool isfood;
          UtilMap     map;
          private class SeenCreature
          {
              public SeenCreature(OrganismState creature, int tick)
              {
                  this.creature = creature;
                  this.tick = tick;
              }
              public OrganismState creature;
              public int tick;
          }
          protected override void Initialize()
          {
              map = new UtilMap(this);
              Load += new LoadEventHandler(LoadEvent);             
              Idle += new IdleEventHandler(IdleEvent);             
              Attacked += new AttackedEventHandler(AttackedEvent); 
          }
          void LoadEvent(object sender, LoadEventArgs e)
          {
              kyoi.Clear();
              kamo.Clear();
              esa.Clear();
              esa2.Clear();
              Attackers.Clear();
              animal.Clear();
              Plants.Clear();
              Friends.Clear();
              Dead.Clear();
              SeenCarnivores.Clear();
              RetiredFriends.Clear();
              isBlocked=false;
              FoundAS.Clear();
              AS.Clear();
              AttackAS.Clear();
              isclose = false;
              isfood = false;
              isCarnivoreNear = false;
              if(OldAge())
                  MyAntenna = Antenna.OldAge;
              else
                  MyAntenna = Antenna.None;
    /*NOX              
    if (State.Generation > 300)
    {
     if (((State.TickAge + 1) % 2) == 0)
    {
     Antennas.RightAntenna = (AntennaPosition)(((State.TickAge + 1) * 83) % 10); 
    }
    else
     Antennas.RightAntenna = (AntennaPosition)(((State.TickAge + 1) * 58) % 10);
    }
    else
     Antennas.RightAntenna = (AntennaPosition)(((State.TickAge + 1) * 83) % 10);
    NOX */
          }
       Point GetBypass(OrganismState target) {
        int dx = target.GridX - State.GridX;
        int dy = target.GridY - State.GridY;
        int size = State.CellRadius + target.CellRadius + 1;
        if(Math.Abs(dx) > Math.Abs(dy)) {
          if(OrganismRandom.Next(2) == 1) {
            return new Point(Position.X,(target.GridY + size) * 8);
          } else {
            return new Point(Position.X,(target.GridY - size) * 8);
          }
        } else {
          if(OrganismRandom.Next(2) == 1) {
            return new Point((target.GridX + size) * 8,Position.Y);
          } else {
            return new Point((target.GridX - size) * 8,Position.Y);
          }
        }
      }
          void IdleEvent(object sender, IdleEventArgs e)
          {
              if(CanReproduce){
                  BeginReproduction(null);
              }
              ScanAll();
              MakeMap();
              if(OldAge()&&Friends.Count > 0)
              {
                  Attack();
                  Defend();
                if(AS.Count>0)
                          map.findingFood(AS);
                  else
                  if(AttackAS.Count>0)
                  {
                      if(!isclose)
                      map.findingFood(AttackAS);
                      else 
                          StopMoving();
                  }
                  else if(FoundAS.Count>0){
                    if(!isclose)
                              map.findingFood(FoundAS);
                      else
                          StopMoving();
                  }else               if(!map.chaseenemy(Friends,Species.MaximumSpeed))
                  {
                      map.ResetCost();
                  }
              }
              else{
                  Eat();
                  Attack();
                  Defend();
                  if(Dead.Count > 0 && !isCarnivoreNear && !isfood){
                      MyAntenna = Antenna.None;
                      if(!map.findingFood(Dead))
                      {
                          map.ResetCost();
                      }
                  }
                  else if (State.StoredEnergy<50)
                  {
                      TryWalk();
                      MyAntenna = Antenna.None;
                  }
                  else if((kamo.Count==0||kyoi.Count>0)&&AS.Count>0)
                      map.chaseenemy(AS,Species.MaximumSpeed);
                else if((kamo.Count==0||kyoi.Count>0)&&AttackAS.Count>0)
                  {
                      if(!isclose)
                          map.chaseenemy(AttackAS,8);
                      else
                          StopMoving();
                  }
                  else if((kamo.Count==0||kyoi.Count>0)&&FoundAS.Count>0){
                     if(!isclose)
                          map.chaseenemy(FoundAS,8);
                      else
                          StopMoving();
                  }
                  else if(kyoi.Count>0 || SeenCarnivores.Count > 0){
                    if(Friends.Count>0&&CellDistanceTo((OrganismState)Friends[0])<4)
                              StopMoving();
                     else
                          map.runawayFromEnemy(kyoi);
                  }
                  else if(kamo.Count>0){
                      MyAntenna = Antenna.None;
                      AnimalState best = (AnimalState) kamo[0];
                      int dist=CellDistanceTo(best);
                      int speed = 12;
                      if(dist<4)
                          speed=Species.MaximumSpeed;
                      else if(best.CurrentMoveToAction != null)
                          speed = Math.Max(12,Math.Min(Species.MaximumSpeed,best.CurrentMoveToAction.MovementVector.Speed+1));
                      else
                          speed=12;
                      if(!map.chaseenemy(kamo,speed))
                      {
                          map.ResetCost();
                      }
                  }
                  else if(esa2.Count>0){
                      AnimalState best = (AnimalState) esa2[0];                  
                      int dist=CellDistanceTo(best);
                      int speed = 3;
                      if(dist<2)
                       speed = Species.MaximumSpeed;
                       if(State.PercentInjured <0.5&&(State.PercentEnergy<0.4||dist<3))
                       map.chaseenemy(esa2,speed);
                  }
                  else if(esa.Count > 0){
                      AnimalState best = esa[0] as AnimalState;
                      int dist=CellDistanceTo(best);
                        StopMoving();
    /*
                      if(Friends.Count ==0)
                      {
                              StopMoving();
                      }
                      else {
                          int speed = 3;
                          if(!map.chaseenemy(esa,speed))
                          {
                              map.ResetCost();
                          }
                      }
                      */
                  }
                  else
                      TryWalk();
              }
              if(OldAge())
                  MyAntenna = Antenna.OldAge;
          }
          void Attack(){
              if(kyoi.Count>0){
                  AnimalState closestCarni =(AnimalState)kyoi[0];
                  if(WithinAttackingRange(closestCarni))
                  {
                      try
                      {
                          BeginAttacking(closestCarni);
                          return;
                      }
                      catch(Exception ex)
                      {
                          WriteTrace(ex.ToString());
                      }
                  }
              }
              if(animal.Count>0){
                  AnimalState a = (AnimalState)animal[0];
                                                    if (CellDistanceTo(a)<5)
                                                    if (a.AnimalSpecies.IsCarnivore|| a.EnergyState == EnergyState.Hungry
                                                         || a.EnergyState == EnergyState.Deterioration||CanWin(a,1))
                                                        try{
                                                            BeginAttacking(a);
                                                            return;
                                                        }
                                                        catch {};
              }
              if(RetiredFriends.Count>0){
                  AnimalState a = (AnimalState)RetiredFriends[0];
                  if (CellDistanceTo(a)<5)
                      try{
                          BeginAttacking(a);
                          return;
                      }
                      catch {};
              }
          }
          void Defend(){
              if(kyoi.Count>0){
                  AnimalState closestCarni =(AnimalState)kyoi[0];
                  if(WithinAttackingRange(closestCarni))
                  {
                      try
                      {
                          BeginDefending(closestCarni);
                          return;
                      }
                      catch(Exception ex)
                      {
                          WriteTrace(ex.ToString());
                      }
                  }
              }
              try{
                  AnimalState a = (AnimalState)animal[0];
                  BeginDefending(a);
              }
              catch{};
          }
         public bool IsMyFriend(AnimalState animalState){
    /*
            if (animalState.Species.Skin ==null)
                return false;
            bool ret = false;
            ret=!animalState.AnimalSpecies.IsCarnivore &&
            (animalState.Species.Skin.StartsWith("mary"));
            ret = ret && animalState.AnimalSpecies.SkinFamily == AnimalSkinFamilyEnum.Beetle;
            return ret;
    */
    /*        if (animalState.Species.Skin ==null)
                return false;
            bool ret = false;
            ret=!animalState.AnimalSpecies.IsCarnivore &&
            ( animalState.AnimalSpecies.LifeSpan == 600 ) &&
            ( animalState.AnimalSpecies.MaximumEnergyPerUnitRadius == 443 ) &&
            ( animalState.AnimalSpecies.EatingSpeedPerUnitRadius == 2 ) &&
            ( animalState.AnimalSpecies.MaximumAttackDamagePerUnitRadius == 50 ) &&
            ( animalState.AnimalSpecies.MaximumDefendDamagePerUnitRadius == 52 ) &&
            ( animalState.AnimalSpecies.MaximumSpeed == 45 ) &&
            ( animalState.AnimalSpecies.EyesightRadius == 6 )
            &&(animalState.Species.Skin.StartsWith("mary"));
            ret = ret && animalState.AnimalSpecies.SkinFamily == AnimalSkinFamilyEnum.Spider;
            return ret;
    */
    /*
            bool ret = false;
            ret=!animalState.AnimalSpecies.IsCarnivore &&
            ret = ret && animalState.AnimalSpecies.SkinFamily == AnimalSkinFamilyEnum.Spider;
            return ret;
            */
              if (animalState.Species.Skin ==null||!animalState.Species.Skin.StartsWith("mari"))
                  return false;
              if(!animalState.AnimalSpecies.IsCarnivore &&animalState.AnimalSpecies.MatureRadius == 24&&animalState.Antennas.LeftAntenna==(AntennaPosition)(((animalState.TickAge) * 33 ) % 10))
                  return true;
            return false;
        }
    /*     public bool IsMyFriend(AnimalState animalState){
            if (animalState.Species.Skin ==null)
                return false;
            bool ret = false;
            ret=!animalState.AnimalSpecies.IsCarnivore &&
            ( animalState.AnimalSpecies.LifeSpan == 600 ) &&
            ( animalState.AnimalSpecies.EatingSpeedPerUnitRadius == 4 ) &&
            ( animalState.AnimalSpecies.MaximumAttackDamagePerUnitRadius == 52 ) &&
            ( animalState.AnimalSpecies.MaximumDefendDamagePerUnitRadius == 57 ) &&
            ( animalState.AnimalSpecies.MaximumSpeed == 30 ) &&
            ( animalState.AnimalSpecies.EyesightRadius == 6 )
            &&(animalState.Species.Skin.StartsWith("mary"));
            ret = ret && animalState.AnimalSpecies.SkinFamily == AnimalSkinFamilyEnum.Ant;
            return ret;
        }
    */
          public Point GetRandPos(){
              Point p;
              do
              {
                  int d = (State.CellRadius+1)<<3;
                  int x = OrganismRandom.Next(d, WorldWidth-d-1);
                  int y = OrganismRandom.Next(d, WorldHeight-d-1);
                  p = new Point(x,y);
              }while( p==Position );
              return p;
          }
          void MoveCompletedEvent(object o, MoveCompletedEventArgs e)
          {
              if( e.Reason == ReasonForStop.Blocked &&e.BlockingOrganism !=null&&e.BlockingOrganism is PlantState)
                  isBlocked=true;
          }
          void TryWalk()
          {
              if(lastRunaway == null)
              {
                  lastRunaway =Vector.Subtract(Position,GetRandPos());
              }
              map.randomwalk(lastRunaway);
          }
          void Eat()
          {
              if( CanEat )
              {
                  foreach( OrganismState o in Dead )
                  {
                      try{
                          BeginEating( o );
                          return;
                      }catch{};
                  }
              }
          }
          public int CellDistanceTo(OrganismState creature)
          {
              return Math.Max(Math.Abs(State.GridX - creature.GridX),
                              Math.Abs(State.GridY - creature.GridY)) -     State.CellRadius - creature.CellRadius - 1;
          }
          public int CellDistanceTo(OrganismState creature1,OrganismState creature2)
          {
              return Math.Max(Math.Abs(creature1.GridX - creature2.GridX),
                              Math.Abs(creature1.GridY - creature2.GridY)) -     creature1.CellRadius - creature2.CellRadius - 1;
          }
          Point GetGrid( Point p ){
              return new Point( p.X>>3 , p.Y>>3 );
          }
          bool OldAge()
          {
              if(State.ReproductionWait > Species.LifeSpan - State.TickAge)
               return true;
            if(State.Species.GrowthWait*(State.Species.MatureRadius - State.Radius)> Species.LifeSpan - State.TickAge)
             return true;
             return false;
          }
          bool OldAge(AnimalState a)
          {
                  if(a.ReproductionWait > a.Species.LifeSpan - a.TickAge)
               return true;
            if(a.Species.GrowthWait*(a.Species.MatureRadius - a.Radius)> a.Species.LifeSpan - a.TickAge)
             return true;
             return false;    
        }
          void AttackedEvent (object sender, AttackedEventArgs e)
          {
              Attackers.Add(e.Attacker);
          }
          private void ScanAll()
          {
              Hashtable tmp1 = new Hashtable() ;
              for( int i = 0 ; i < 3 ; i++ ){
                  ArrayList tmp = Scan();
                  foreach (OrganismState creature in tmp)
                  {
                      if(tmp1.ContainsKey(creature.ID))
                          tmp1.Remove(creature.ID);
                      tmp1.Add(creature.ID,creature);
                  }
              }
              ArrayList tmp2= new ArrayList();
              foreach(OrganismState creature in Creatures.Values) {
                if(creature == null )
                    continue;
                  if(tmp1.ContainsKey(creature.ID))
                      tmp2.Add(creature.ID);
                  else
                      {
                          int j = 1;
                          AnimalState an = creature as AnimalState;
                          if(an != null &&an.AnimalSpecies.InvisibleOdds >0)
                              j = 10;
                          OrganismState org = null ;
                          int i = 0;
                          do{
                              org = RefreshState(creature.ID);
                              if(org != null && !tmp1.ContainsKey(creature.ID))
                                  tmp1.Add(creature.ID,org);
                              i++;
                          }
                          while( i < j && org == null);
                          if(org ==null && !tmp2.Contains(creature.ID))
                              tmp2.Add(creature.ID);
                      }
              }
              foreach(String str in tmp2){
                  if(SeenCreatures.ContainsKey(str))
                      SeenCreatures.Remove(str);
                  if(Creatures[str] != null&&((OrganismState)Creatures[str]).IsAlive)
                      SeenCreatures.Add(str,new SeenCreature((OrganismState) Creatures[str], State.TickAge));
              }
              Creatures = tmp1;
              foreach(OrganismState org in Attackers)
                  if(!Creatures.ContainsKey(org.ID))
                      Creatures.Add(org.ID,org);
              foreach(OrganismState org in Creatures.Values) {
                if(org == null )
                        continue;
                  if(SeenCreatures.ContainsKey(org.ID))
                      SeenCreatures.Remove(org.ID);
                  if(org is PlantState){
                      Plants.Add(org);
                      if(CellDistanceTo(org)<=Species.MaximumSpeed>>3+1)
                          isBlocked=true;
                  }
                  else {
                      if(!((AnimalState)org).IsAlive)
                          Dead.Add(org);
                      else
                          if(IsMySpecies((AnimalState)org)){
                              if(AnimalAntenna((AnimalState)org)==Antenna.FoundAS){
                                  if(CellDistanceTo(org)==0)
                                      isclose=true;
                                  FoundAS.Add(org);
                              }
                              if(AnimalAntenna((AnimalState)org)==Antenna.AttackAS){
                                  if(CellDistanceTo(org)==0)
                                      isclose=true;
                                  AttackAS.Add(org);
                              }
                              if(AnimalAntenna((AnimalState)org)==Antenna.OldAge)
                                  RetiredFriends.Add(org);
                              else {
                                  if(CellDistanceTo(org)<=Species.MaximumSpeed>>3+1)
                                      isBlocked=true;
                                  Friends.Add(org);
                              }
                          }
                          else {
                              animal.Add(org);
                              if(((AnimalState)org).AnimalSpecies.IsCarnivore){
                                  if(CanWin((AnimalState) org,0.8 ))
                                      kamo.Add(org);
                                  else {
                                    if(CellDistanceTo(org)<2 )
                                          MyAntenna = Antenna.AttackAS;
                                      else
                                        MyAntenna = Antenna.FoundAS;
                                      if(!CanWin((AnimalState) org,1.1)){
                                    AS.Add(org);
                                          kyoi.Add(org);
                                          if(CellDistanceTo(org)<5)
                                              isCarnivoreNear=true;
                                      }
                                  }
                              }
                              else if(IsMyFriend((AnimalState)org))
                              {
                                if(!OldAge((AnimalState)org))
                                    animal.Remove(org);
                                  esa.Add(org);
                              }
                              else {
                                    if(!CanWin((AnimalState) org,1.1))
                                    {                            
                                      }
                                      else 
                                          esa2.Add(org);
                              }
                          }
                  }
              }
    /*          if(AttackAS.Count>0 && AS.Count == 0){
                  if(OldAge())
                      MyAntenna = Antenna.OldAge;
                  else
                      MyAntenna = Antenna.None;
              }
    */
              ArrayList keys = new ArrayList();
              foreach(String str in SeenCreatures.Keys){
                if(SeenCreatures[str] == null)
                    continue;
                  int tick = 7;
                  AnimalState an2 = Creatures[str] as AnimalState;
                  if(an2 != null &&an2.AnimalSpecies.InvisibleOdds >0)
                      tick = 15;
                  if (this.State.TickAge - ((SeenCreature) SeenCreatures[str]).tick > tick)
                      keys.Add(str);
                  else
                      {
                          AnimalState an = ((SeenCreature) SeenCreatures[str]).creature as AnimalState;
                          if(an != null
                             &&an.IsAlive
                             &&an.AnimalSpecies.IsCarnivore
                             &&!CanWin(an,1.1))
                             SeenCarnivores.Add(an.Position);
                      }
              }
              foreach(String str in keys)
                  SeenCreatures.Remove(str);
              DistComparer3 dc =new DistComparer3(this);
            if(Attackers.Count>1)
              foreach(OrganismState os in Attackers){
                  if(!kyoi.Contains(os))
                      kyoi.Add(os); 
                  if(!SeenCarnivores.Contains(os.Position))
                   SeenCarnivores.Add(os.Position);
              }
              kyoi.Sort(dc);
              kamo.Sort(dc);
              esa.Sort(dc);
              esa2.Sort(dc);
              animal.Sort(dc);
              RetiredFriends.Sort(dc);
              Plants.Sort(dc);
              Friends.Sort(dc);
              Dead.Sort(dc);
              ArrayList tmp3 = new ArrayList();
              AS.Sort(dc);
              foreach(AnimalState as1 in AS)
              {
                int best = CellDistanceTo((OrganismState)AS[0]);
                  foreach(AnimalState as2 in AttackAS)
                  {
                    int dist = CellDistanceTo(as1,as2);
                      if(    dist<5&&dist<=best&&!tmp3.Contains(as1))
                          tmp3.Add(as1);
                  }
                  foreach(AnimalState as2 in FoundAS)
                  {
                    int dist = CellDistanceTo(as1,as2);
                      if(    dist<5&&dist<=best&&!tmp3.Contains(as1))
                          tmp3.Add(as1);
                  }
              }
              AS = tmp3;
              if(Dead.Count>0 && kyoi.Count>0)
              foreach(AnimalState as1 in Dead)
            {
                int best = 100;
                  foreach(AnimalState as2 in kyoi)
                {
                if(!as2.AnimalSpecies.IsCarnivore)
                    continue;
                    int dist = CellDistanceTo(as1,as2);        
                    if(best > dist)
                        best = dist;
                }
                if(best < CellDistanceTo(as1))
                    isfood = true;    
            }
          }
          private double LeftTicks(AnimalState d,AnimalState a) {
              double dHitpoint = EngineSettings.DamageToKillPerUnitOfRadius * d.Radius - d.Damage;
              double aAttackpoint = a.AnimalSpecies.MaximumAttackDamagePerUnitRadius * a.Radius;
              double dDefendpoint = d.AnimalSpecies.MaximumDefendDamagePerUnitRadius * d.Radius;
              return dHitpoint / Math.Max(1,aAttackpoint - dDefendpoint + 500);
          }
          private bool CanWin(AnimalState target,double canWinAlpha) {
              if(target == null) return false;
              return canWinAlpha*LeftTicks(State,target) > LeftTicks(target,State);
          }
          /*
          private bool CanWin(AnimalState defender,double canWinAlpha) {
              double attackerAttackDefend  = (State.AnimalSpecies.MaximumAttackDamagePerUnitRadius+State.AnimalSpecies.MaximumDefendDamagePerUnitRadius)*State.Radius;
              double defenderAttackDefend  = (defender.AnimalSpecies.MaximumAttackDamagePerUnitRadius+defender.AnimalSpecies.MaximumDefendDamagePerUnitRadius)*defender.Radius;
              double attackerCanLoose = EngineSettings.DamageToKillPerUnitOfRadius*State.Radius-State.Damage;
              double defenderCanLoose = EngineSettings.DamageToKillPerUnitOfRadius*defender.Radius-defender.Damage;
              if(defenderCanLoose<0) defenderCanLoose=0.01;
              if(attackerCanLoose<0) attackerCanLoose=0.01;
              return  ((attackerCanLoose*attackerAttackDefend) / (defenderCanLoose*defenderAttackDefend) > canWinAlpha);
          }
          public double CanWin(AnimalState defender)
          {
              double attackerCanLoose = EngineSettings.DamageToKillPerUnitOfRadius*State.Radius-State.Damage;
              double defenderCanLoose = EngineSettings.DamageToKillPerUnitOfRadius*defender.Radius-defender.Damage;
              if(defenderCanLoose<0) defenderCanLoose=0.01;
              if(attackerCanLoose<0) attackerCanLoose=0.01;
              double attackerAttackDefend  = (State.AnimalSpecies.MaximumAttackDamagePerUnitRadius+State.AnimalSpecies.MaximumDefendDamagePerUnitRadius)*State.Radius;
              double defenderAttackDefend  = (defender.AnimalSpecies.MaximumAttackDamagePerUnitRadius+defender.AnimalSpecies.MaximumDefendDamagePerUnitRadius)*defender.Radius;
              return  ((attackerCanLoose*attackerAttackDefend) / (defenderCanLoose*defenderAttackDefend));
          }
          */
          private void MakeMap()
          {
              map.Update();
          }
          public OrganismState ClosestCreature(ArrayList array)
          {
              if ((array == null) || (array.Count == 0))
                  return null;
              OrganismState bestCreature = (OrganismState) array[0];
              foreach (OrganismState creature in array)
                  if (DistanceTo(creature) < DistanceTo(bestCreature))
                      bestCreature = creature;
              return bestCreature;
          }
          private Antenna MyAntenna
          {
              get
              {
                  return (Antenna) this.Antennas.LeftAntenna;
              }
              set
              {
                  this.Antennas.LeftAntenna = (AntennaPosition) value;
              }
          }
          private Antenna AnimalAntenna(AnimalState animal)
          {
              return (Antenna) animal.Antennas.LeftAntenna;
          }
          private enum Antenna
          {
              None = AntennaPosition.Bottom,
              OldAge = AntennaPosition.Backward,
              FoundAS = AntennaPosition.Left,
              AttackAS = AntennaPosition.BottomLeft
          }
          public override void SerializeAnimal(MemoryStream m)
          {
          }
          public override void DeserializeAnimal(MemoryStream m)
          {
          }
      }
      public class UtilMap
      {
          private class DistComparer : IComparer {
              Vector v;
              public DistComparer(Vector v) {
                  this.v =v;
              }
              public int Compare(object a,object b) {
                  if(a==null || b ==null)
                      return 0;
                  Vector va = Vector.Subtract(new Point(0,0),(Point)a);
                  Vector vb = Vector.Subtract(new Point(0,0),(Point)b);
                  va = va.GetUnitVector();
                  vb = vb.GetUnitVector();
                  double da = v.X*va.X+v.Y*va.Y;
                  double db = v.X*vb.X+v.Y*vb.Y;
                  return((int)(db - da));
              }
          }
          private class DistComparer2 : IComparer {
              ArrayList enemies;
              Point myPoint;
              Animal my;
              public DistComparer2(ArrayList enemies,Point myPoint,Animal my) {
                  this.enemies = enemies;
                  this.myPoint = myPoint;
                  this.my      = my;
              }
              public int Compare(object a,object b) {
                  if(a==null || b ==null)
                      return 0;
                  int ax = ((Point)a).X;
                  int ay = ((Point)a).Y;
                  int bx = ((Point)b).X;
                  int by = ((Point)b).Y;
                  double besta = -1;
                  double bestb = -1;
                  foreach(Point enemy in enemies)
                  {
                      double tmpa =((enemy.X-myPoint.X)*ax+(enemy.Y-myPoint.Y)*ay)
                      /(Math.Sqrt((enemy.X-myPoint.X)*(enemy.X-myPoint.X)+(enemy.Y-myPoint.Y)*(enemy.Y-myPoint.Y))
                        *Math.Sqrt(ax*ax+ay*ay));
                      double tmpb =((enemy.X-myPoint.X)*bx+(enemy.Y-myPoint.Y)*by)
                      /(Math.Sqrt((enemy.X-myPoint.X)*(enemy.X-myPoint.X)+(enemy.Y-myPoint.Y)*(enemy.Y-myPoint.Y))
                        *Math.Sqrt(bx*bx+by*by));
                      if(besta < tmpa)
                          besta = tmpa;
                      if(bestb < tmpb)
                          bestb = tmpb;
                  }
                  if(my.State.CurrentMoveToAction != null) {
                      MovementVector mv = my.State.CurrentMoveToAction.MovementVector;
                      Point D = mv.Destination;
                      double tmpa =((myPoint.X-D.X)*ax+(myPoint.Y-D.Y)*ay)
                      /(Math.Sqrt((D.X-myPoint.X)*(D.X-myPoint.X)+(D.Y-myPoint.Y)*(D.Y-myPoint.Y))
                        *Math.Sqrt(ax*ax+ay*ay));
                      double tmpb =((myPoint.X-D.X)*bx+(myPoint.Y-D.Y)*by)
                      /(Math.Sqrt((D.X-myPoint.X)*(D.X-myPoint.X)+(D.Y-myPoint.Y)*(D.Y-myPoint.Y))
                        *Math.Sqrt(bx*bx+by*by));
                      if(besta < tmpa)
                          besta = tmpa;
                      if(bestb < tmpb)
                          bestb = tmpb;
                  }
                  return (Math.Sign(besta - bestb));
              }
              private int CellDistance(Point P1 , Point P2)
              {
                  return Math.Max(Math.Abs(P1.X>>3 - P2.X>>3 ),
                                  Math.Abs(P1.Y>>3 - P2.Y>>3 )) - 5;
              }
          }
          /*      private class DistComparer2 : IComparer {
              ArrayList enemies;
              Point myPoint;
              public DistComparer2(ArrayList enemies,Point myPoint) {
                  this.enemies = enemies;
                  this.myPoint = myPoint;
              }
              public int Compare(object a,object b) {
                  if(a==null || b ==null)
                      return 0;
                  int  da = 0;
                  int  db = 0;
                  int dax = 0;
                  int day = 0;
                  int dbx = 0;
                  int dby = 0;
                  int ax = ((Point)a).X<<3;
                  int ay = ((Point)a).Y<<3;
                  int bx = ((Point)b).X<<3;
                  int by = ((Point)b).Y<<3;
                  foreach(Point enemy in enemies)
                  {
                      dax +=enemy.X-(ax+myPoint.X);
                      day +=enemy.Y-(ay+myPoint.Y);
                      dbx +=enemy.X-(bx+myPoint.X);
                      dby +=enemy.Y-(by+myPoint.Y);
                  }
                  da=dax*dax+day*day;
                  db=dbx*dbx+dby*dby;
                  return((int)(db - da));
              }
              */
              /*    public int Compare(object a,object b) {
                  if(a==null || b ==null)
                      return 0;
                  double da = 0;
                  double db = 0;
                  int ax = ((Point)a).X<<3;
                  int ay = ((Point)a).Y<<3;
                  int bx = ((Point)b).X<<3;
                  int by = ((Point)b).Y<<3;
                  foreach(Point enemy in enemies)
                  {
                      int tmp;
                      tmp =( (enemy.X-(ax+myPoint.X))*(enemy.X-(ax+myPoint.X))
                            +(enemy.Y-(ay+myPoint.Y))*(enemy.Y-(ay+myPoint.Y)));
                      if(tmp == 0)
                          da = int.MaxValue;
                      else
                          da +=100000000/tmp;
                      tmp = ((enemy.X-(bx+myPoint.X))*(enemy.X-(bx+myPoint.X))
                             +(enemy.Y-(by+myPoint.Y))*(enemy.Y-(by+myPoint.Y))) ;
                      if(tmp == 0)
                          db = int.MaxValue;
                      else
                          db += 100000000/tmp;
                  }
                  return((int)(da - db));
              }
              */
              private MyCreature my;
          private int XSize, YSize;
          private int MapPosX, MapPosY;
          private int MaxX;
          private int MaxY;
          private bool[,] blocked ;
          private bool[,] creatures ;
          public int [,] costs;
          private Queue queue ;
          Point   foundPoint;
          Point   beginPoint;
          ArrayList Direction4;
          ArrayList Direction8;
          int d,e;
          public UtilMap(MyCreature my)
          {
              this.my=my;
              MaxX = my.WorldWidth >> EngineSettings.GridWidthPowerOfTwo;
              MaxY = my.WorldHeight>> EngineSettings.GridHeightPowerOfTwo;
              XSize = my.Species.EyesightRadius;
              YSize = my.Species.EyesightRadius;
              Direction4 = new ArrayList(4);
              Direction8 = new ArrayList(8);
              blocked = new bool[XSize<<1+1,YSize<<1+1];
              creatures = new bool[XSize<<1+1,YSize<<1+1];
              costs = new int[XSize<<1+1,YSize<<1+1];
              queue = new Queue();
              /*        direction = new Point[2,2,2,4];
              for(int i=0;i<2;i++)
                  for(int j=0;j<2;j++)
                      for(int k=0;k<2;k++)
                      {
                          direction[i,j,k,0]=new Point((i==0?0:1)*(j==0?1:-1),(i==0?1:0)*(k==0?1:-1));
                          direction[i,j,k,1]=new Point((i==0?1:0)*(j==0?1:-1),(i==0?0:1)*(k==0?1:-1));
                          direction[i,j,k,2]=new Point((i==0?1:0)*(j==0?-1:1),(i==0?0:1)*(k==0?-1:1));
                          direction[i,j,k,3]=new Point((i==0?0:1)*(j==0?-1:1),(i==0?1:0)*(k==0?-1:1));
                      }
                      */
                      for(int x=-1;x<=1;x++)
                          for(int y=-1;y<=1;y++)
                          {
                              if(Math.Abs(x)!=Math.Abs(y))
                                  Direction4.Add(new Point(x,y));
                              if(x!=0||y!=0)
                                  Direction8.Add(new Point(x,y));
                          }
          }
          public void Update()
          {
              Reset();
              foreach(OrganismState creature in my.Plants) {
                  addBlocker(creature);
              }
              foreach(OrganismState creature in my.Friends) {
                  addBlocker(creature);
              }
              foreach(OrganismState creature in my.kyoi) {
                  addBlocker(creature);
              }
              foreach(OrganismState creature in my.esa) {
                  addBlocker(creature);
              }          
              foreach(OrganismState creature in my.Dead) {
                  addBlocker(creature);
              }
          }
          public void ResetCost()
          {
              for(int i=0;i<=XSize<<1;i++)
                  for(int ii=0;ii<=YSize<<1;ii++)
                      costs[i,ii] =int.MaxValue;
              queue.Clear();
          }
          private void Reset()
          {
              d = ((Int32)Math.Round( Math.Cos( (double)my.State.ActualDirection / 180 * Math.PI ) * my.State.Speed ));
              e = ((Int32)Math.Round( Math.Sin( (double)my.State.ActualDirection / 180 * Math.PI ) * my.State.Speed ));
              MapPosX = my.Position.X >> EngineSettings.GridWidthPowerOfTwo;
              MapPosY = my.Position.Y >> EngineSettings.GridHeightPowerOfTwo;
              int a = my.State.CellRadius;
              int b = MaxX-a;
              int c = MaxY-a;
              for(int i=0;i<=XSize<<1;i++) {
                  for(int ii=0;ii<=YSize<<1;ii++)
                  {
                      creatures[i,ii] = false;
                      costs[i,ii] =int.MaxValue;
                      int x = i+MapPosX-XSize;
                      int y = ii+MapPosY-YSize;
                      if(x<=a || x>=b||y<=a || y>=c)
                      {
                          blocked[i,ii]= true;
                      }
                      else
                          {
                              blocked[i,ii]= false;
                          }
                  }
              }
              queue.Clear();
          }
          private Point GetRealPoint(Point m)
          {
              Point p = new Point((int)((m.X+MapPosX-XSize)*EngineSettings.GridCellWidth),
                                  (int)((m.Y+MapPosY-YSize)*EngineSettings.GridCellHeight));
              return p;
          }
          public bool findingFood(ArrayList foods)
          {
              foundPoint = new Point(XSize,YSize);
              beginPoint = foundPoint;
              foreach(OrganismState food in foods) {
                  if(my.State.IsAdjacentOrOverlapping(food))
                  {
                      return true;
                  }
                  addCreature(food);
              }
              if(creatures[XSize,YSize])
                  return false;
              queue.Enqueue(new Point(XSize,YSize));
              costs[XSize,YSize]=0;
              while(queue.Count>0&&(foundPoint.X == XSize&&foundPoint.Y == YSize))
                  calcPath();
              if(foundPoint.X!=XSize||foundPoint.Y!=YSize)
              {
                  try{
                      int speed = 12;
                      if(my.AS.Count>0)
                          speed = my.Species.MaximumSpeed;
                      my.BeginMoving(GetMovementVector2(backTrace2(foundPoint),speed));
                      return true;
                  }catch{};
              }
              return false;
          }
          public bool chaseenemy(ArrayList foods,int speed)
          {
                  foundPoint = new Point(XSize,YSize);
              beginPoint = foundPoint;
              costs[beginPoint.X,beginPoint.Y]=0;
                  if(!my.isBlocked )
                  {
                      OrganismState food = (OrganismState) foods[0];
                      double dist = my.DistanceTo(food);
                      Point p = food.Position;
                      if(food.CurrentMoveToAction != null) {
                          MovementVector mv = food.CurrentMoveToAction.MovementVector;
                          Point D = mv.Destination;
                          Vector vector = Vector.Subtract(food.Position,D);
                          vector = vector.GetUnitVector().Scale(dist * 0.03 * mv.Speed);
                          p = RangeCheck(Vector.Add(p,vector));
                      }
                      /*
                      if(my.CellDistanceTo(food) < 2){
                          Point myp = new Point(my.Position.X-d,my.Position.Y-e);
                          p =RangeCheck(Vector.Add(myp,Vector.Subtract(myp,p).Scale(100)));
                          speed = my.Species.MaximumSpeed;
                      }
                      */
                      if(p != Point.Empty)
                          my.BeginMoving(new MovementVector(p,MinSpeedToReachPointInTick(p,speed)));
                      /*                  if(!my.IsMySpecies(food)){
                          try{
                              my.BeginAttacking(food as AnimalState);
                              my.BeginDefending(food as AnimalState);
                          }
                          catch{};
                      }
                      */
                      return true;
                  }
                  foreach(OrganismState food in foods) {
                      addCreature(food);
                  }
                  if(creatures[beginPoint.X,beginPoint.Y])
                      return true;
              queue.Enqueue(beginPoint);
              Vector v = Vector.Subtract(my.Position,((OrganismState)foods[0]).Position);
              Direction4.Sort(new DistComparer(v));
              Direction8.Sort(new DistComparer(v));
              while(queue.Count>0&&foundPoint == beginPoint)
              {
                  if(my.isBlocked)
                  {
                      calcPath();
                  }
                  else
                      {
                          calcPath2();
                      }
              }
              if(foundPoint!=beginPoint)
              {
                  try{
                      if(my.isBlocked)
                          my.BeginMoving(GetMovementVector2(backTrace2(foundPoint),speed));
                      else
                          my.BeginMoving(GetMovementVector(backTrace(foundPoint),speed));
                      return true;
                  }catch{
                  }
              }
              return false;
          }
          private void calcPath()
          {
              Point p = (Point)(queue.Dequeue());
              foreach(Point q in Direction4){
                  int X = q.X+p.X;
                  int Y = q.Y+p.Y;
                  if(X>=0&&Y>=0&&X<=(XSize<<1)&&Y<=(YSize<<1)&&!blocked[X,Y] &&costs[X,Y]>costs[p.X,p.Y]+1)
                  {
                      costs[X,Y]=costs[p.X,p.Y]+1;
                      Point tmp = new Point(X,Y);
                      if(!queue.Contains(tmp))
                          queue.Enqueue(tmp);
                      if(creatures[X,Y] == true)
                      {
                          foundPoint= tmp;
                          return;
                      }
                  }
              }
          }
          private void calcPath2()
          {
              Point p = (Point)(queue.Dequeue());
              foreach(Point q in Direction8){
                  int X = q.X+p.X;
                  int Y = q.Y+p.Y;
                  int cost = 0;
                  if((q.X==-1||q.X==1)&&(q.Y==-1||q.Y==1))
                      cost = 3;
                  else
                      cost = 2;
                  if(X>=0&&Y>=0&&X<=(XSize<<1)&&Y<=(YSize<<1)&&!blocked[X,Y] &&costs[X,Y]>costs[p.X,p.Y]+cost)
                  {
                      costs[X,Y] = costs[p.X,p.Y]+cost;
                      Point tmp = new Point(X,Y);
                      if(!queue.Contains(tmp))
                          queue.Enqueue(tmp);
                      if(creatures[X,Y] == true)
                      {
                          foundPoint= tmp;
                          return;
                      }
                  }
              }
          }
          public void runawayFromEnemy(ArrayList enemies)
          {
              ArrayList distance=new ArrayList();
                  foundPoint = new Point(XSize,YSize);
              beginPoint = foundPoint;
              /*        foreach(OrganismState enemy in enemies) {
                  int xpos = (enemy.Position.X >> EngineSettings.GridWidthPowerOfTwo)-MapPosX+XSize;
                  int ypos = (enemy.Position.Y >> EngineSettings.GridHeightPowerOfTwo)-MapPosY+YSize;
                  beginX += xpos;
                  beginY += ypos;
                  addCreature(enemy);
              }
              beginPoint = new Point ((int)(beginX/enemies.Count),(int)(beginY/enemies.Count));
              */
              costs[beginPoint.X,beginPoint.Y]=0;
              foreach(OrganismState enemy in enemies)
              {
                  distance.Add(enemy.Position);
              }
              foreach(Point F in my.SeenCarnivores)
                  distance.Add(F);
              Point P = my.Position;
                  Direction4.Sort(new DistComparer2(distance,P,my));
              Direction8.Sort(new DistComparer2(distance,P,my));
              if(my.isBlocked)
              {
                  calcPath4(beginPoint.X,beginPoint.Y,Point.Empty);
              }
              else
                  {
                      calcPath5(beginPoint.X,beginPoint.Y,Point.Empty);
                  }
                  if(foundPoint!=beginPoint){
                      AnimalState an;
                      int speed;
                      if(enemies.Count>0)
                      {
                          an =(AnimalState)enemies[0];
                          /*
                          int xpos = (an.Position.X >> EngineSettings.GridWidthPowerOfTwo)-MapPosX;
                          int ypos = (an.Position.Y >> EngineSettings.GridHeightPowerOfTwo)-MapPosY;
                          if((foundPoint.X-XSize)*xpos*(foundPoint.Y-YSize)*ypos>0)
                              a=Math.Abs(an.Position.X-my.Position.X) < Math.Abs(an.Position.Y-my.Position.Y)?0:1;
                          else
                              a=(foundPoint.X-XSize)*xpos>0?0:1;
                          b=an.Position.X<0?0:1;
                          c=an.Position.Y<0?0:1;
                          */
                          double h = (Vector.Subtract(my.Position,an.Position)).Magnitude;
                          speed = h>80 ? Math.Min(Math.Max(an.Speed+2 ,3),my.Species.MaximumSpeed) :  my.Species.MaximumSpeed;
                        }
                      else
                          speed = 3;
                      try{
                          if(my.isBlocked)
                              my.BeginMoving(GetMovementVector2(backTrace2(foundPoint),speed));
                          else
                              my.BeginMoving(GetMovementVector(backTrace(foundPoint),speed));
                      }catch{
                      }
                  }
          }
          public void randomwalk(Vector v)
          {
                  foundPoint = new Point(XSize,YSize);
              beginPoint = foundPoint;
              /*        foreach(OrganismState enemy in enemies) {
                  int xpos = (enemy.Position.X >> EngineSettings.GridWidthPowerOfTwo)-MapPosX+XSize;
                  int ypos = (enemy.Position.Y >> EngineSettings.GridHeightPowerOfTwo)-MapPosY+YSize;
                  beginX += xpos;
                  beginY += ypos;
                  addCreature(enemy);
              }
              beginPoint = new Point ((int)(beginX/enemies.Count),(int)(beginY/enemies.Count));
              */
              costs[beginPoint.X,beginPoint.Y]=0;
                  if(v != null){
                      Direction4.Sort(new DistComparer(v));
                      Direction8.Sort(new DistComparer(v));
                  }
                  if(my.isBlocked)
                  {
                      calcPath4(beginPoint.X,beginPoint.Y,Point.Empty);
                  }
                  else
                      {
                          calcPath5(beginPoint.X,beginPoint.Y,Point.Empty);
                      }
                      if(foundPoint!=beginPoint){
                          try{
                              if(my.isBlocked)
                                  my.BeginMoving(GetMovementVector2(backTrace2(foundPoint),3));
                              else
                                  my.BeginMoving(GetMovementVector(backTrace(foundPoint),3));
                          }catch{
                          }
                      }
          }
          private bool calcPath4(int x,int y , Point P)
          {
              if(x==0||y==0||x==(XSize<<1)||y==(YSize<<1))
              {
                  foundPoint = new Point(x,y);
                  return true;
              }
              if(P != Point.Empty ){
                  if(x+P.X>=0&&y+P.Y>=0&&x+P.X<=(XSize<<1)&&y+P.Y<=(YSize<<1)&&!blocked[x+P.X,y+P.Y] )
                  {
                      int cost=costs[x,y]+2;
                      if(costs[x+P.X,y+P.Y]>cost)
                      {
                          costs[x+P.X,y+P.Y]=cost;
                          if(calcPath4(x+P.X,y+P.Y,P))
                              return true;
                      }
                  }
              }
              foreach(Point p in Direction4)
                  if(x+p.X>=0&&y+p.Y>=0&&x+p.X<=(XSize<<1)&&y+p.Y<=(YSize<<1)&&!blocked[x+p.X,y+p.Y] )
                  {
                      int cost=costs[x,y]+2;
                      if(costs[x+p.X,y+p.Y]>cost)
                      {
                          costs[x+p.X,y+p.Y]=cost;
                          if(calcPath4(x+p.X,y+p.Y,p))
                              return true;
                      }
                  }
                  return false;
          }
          private bool calcPath5(int x,int y,Point P)
          {
              if(x==0||y==0||x==(XSize<<1)||y==(YSize<<1))
              {
                  foundPoint = new Point(x,y);
                  return true;
              }
              if(P != Point.Empty)
                  if(x+P.X>=0&&y+P.Y>=0&&x+P.X<=(XSize<<1)&&y+P.Y<=(YSize<<1)&&!blocked[x+P.X,y+P.Y] )
                  {
                      int cost;
                      if((P.X==-1||P.X==1)&&(P.Y==-1||P.Y==1))
                          cost=costs[x,y]+3;
                      else
                          cost=costs[x,y]+2;
                      if(costs[x+P.X,y+P.Y]>cost)
                      {
                          costs[x+P.X,y+P.Y]=cost;
                          if(calcPath5(x+P.X,y+P.Y,P))
                              return true;
                      }
                  }
                  foreach(Point p in Direction8)
                      if(x+p.X>=0&&y+p.Y>=0&&x+p.X<=(XSize<<1)&&y+p.Y<=(YSize<<1)&&!blocked[x+p.X,y+p.Y] )
                      {
                          int cost;
                          if((p.X==-1||p.X==1)&&(p.Y==-1||p.Y==1))
                              cost=costs[x,y]+3;
                          else
                              cost=costs[x,y]+2;
                          if(costs[x+p.X,y+p.Y]>cost)
                          {
                              costs[x+p.X,y+p.Y]=cost;
                              if(calcPath5(x+p.X,y+p.Y,p))
                                  return true;
                          }
                      }
                      return false;
          }
          private ArrayList backTrace(Point target)
          {
              ArrayList ret = new ArrayList();
              Point last = target;
              int dx = target.X-XSize;
              int dy = target.Y-YSize;
              ret.Add(target);
              while(last!=beginPoint)
              {
                  Point best = last;
                      foreach(Point p in Direction8)
                      {
                          int X=last.X+p.X;
                          int Y=last.Y+p.Y;
                          if(X>=0&&X<=XSize<<1&&Y>=0&&Y<=YSize<<1&&costs[X,Y]=0&&X<=XSize<<1&&Y>=0&&Y<=YSize<<1&&costs[X,Y]0)
              {
                  moveTo = (Point) path[1];
                  moveFrom = (Point) path[0];
              }
              else
                  {
                      return null;;
                  }
                  int pos=1;
              Point next = (Point)path[0];
              Point last;
              do
              {
                  last = next;
                  if(pos0)
              {
                  moveTo = (Point) path[1];
                  moveFrom = (Point) path[0];
              }
              else
                  {
                      return null;;
                  }
                  int pos=1;
              Point next = (Point)path[0];
              Point last;
              do
              {
                  last = next;
                  if(pos> EngineSettings.GridWidthPowerOfTwo)-MapPosX+XSize;
              int ypos = (o.Position.Y >> EngineSettings.GridHeightPowerOfTwo)-MapPosY+YSize;
              int size = o.CellRadius+my.State.CellRadius;
              for (int i=Math.Max(xpos-size,0); i<=Math.Min(xpos+size,XSize<<1); i++)
                  for (int ii=Math.Max(ypos-size,0); ii<=Math.Min(ypos+size,YSize<<1); ii++)
                  {
                      blocked[i,ii] = true;
                  }
          }
          private void addCreature(OrganismState o)
          {
              int xpos = (o.Position.X >> EngineSettings.GridWidthPowerOfTwo)-MapPosX+XSize;
              int ypos = (o.Position.Y >> EngineSettings.GridHeightPowerOfTwo)-MapPosY+YSize;
              int size = o.CellRadius+my.State.CellRadius+1;
              for (int i=xpos-size; i<=xpos+size; i++)
                  for (int ii=ypos-size; ii<=ypos+size; ii++)
                  {
                      creatures[Math.Max(Math.Min(i,XSize<<1),0),Math.Max(0,Math.Min(ii,YSize<<1))] = true;
                  }
          }
          private void addCreature(ArrayList a)
          {
              foreach(OrganismState o in a)
            {
                  int xpos = (o.Position.X >> EngineSettings.GridWidthPowerOfTwo)-MapPosX+XSize;
                  int ypos = (o.Position.Y >> EngineSettings.GridHeightPowerOfTwo)-MapPosY+YSize;
                  int size = o.CellRadius+my.State.CellRadius+1;
                  for (int i=xpos-size; i<=xpos+size; i++)
                      for (int ii=ypos-size; ii<=ypos+size; ii++)
                      {
                        int x = Math.Max(Math.Min(i,XSize<<1),0);
                        int y = Math.Max(0,Math.Min(ii,YSize<<1));
                        bool flag = false;
                          foreach(OrganismState o2 in a)
                          {
                              if(o2 != o && CellDistanceTo( o2 , x + MapPosX - XSize , y + MapPosY - YSize , o.CellRadius)> EngineSettings.GridWidthPowerOfTwo)-MapPosX+XSize;
              int ypos = (o.Position.Y >> EngineSettings.GridHeightPowerOfTwo)-MapPosY+YSize;
              creatures[Math.Max(Math.Min(xpos,XSize<<1),0),Math.Max(0,Math.Min(ypos,YSize<<1))] = true;
          }
          protected Point RangeCheck(Point point) {
              int x = point.X;
              int y = point.Y;
              x = (x < 0) ? 0 : (my.WorldWidth <= x) ? my.WorldWidth-1 : x;
              y = (y < 0) ? 0 : (my.WorldWidth <= y) ? my.WorldWidth-1 : y;
              return new Point(x,y);
          }
      }