//This sample was based on the template and sample codes 
// provided at http://www.gotdotnet.com/terrarium/ 
// I used them to learn all the possibilities and tried to combine the 
// most helpful features and algorithms to create this simple example. 

using System; 
using System.Drawing; 
using System.Collections; 
using System.IO; 
// Every organism assembly must have all the attributes below defined on it [assembly: OrganismClass("MyCreature")] 
// The class that derives from Animal [assembly: AuthorInformation("Your Name Here!!!", "Your EMAIL here")] 
// Your Email Alias [CarnivoreAttribute(true)] 
// true for carnivores, false for herbivores [MatureSize(25)] 
// smaller -> reproduce quicker between 25 and 45 
// fill in the question marks below with corresponding attributes 
// [AnimalSkin(AnimalSkinFamilyEnum.?)] 
// [MarkingColor(KnownColor.?)] 
// Point Based Attributes: You get 100 points to distribute among these 
// attributes to define what your organism can do. Choose based on strategy. [MaximumEnergyPoints(5)] 
// how much energy the creature can store [EatingSpeedPoints(5)] 
// how fast the creature can eat [AttackDamagePoints(16)] 
// how well the creature attacks in increments of 4 [DefendDamagePoints(12)] 
// how well the creature defends in increments of 4 [MaximumSpeedPoints(12)] 
// how fast the creature can move [CamouflagePoints(0)] 
// how well the creature can hide [EyesightPoints(50)] 
// how far the creature can see in increments of 10 
// Organism Classes must be serializable 
public class MyCreature : Animal { 
    Point parentLocation = new Point(-1,-1); 
    // hello, mother AnimalState targetAnimal = null; 
    // current target (hunting for, eating, attacking) int huntingSpeed; int cruisingSpeed; 
    // Set up event handlers when first initialized 
    protected override void Initialize() { 
        huntingSpeed = Species.MaximumSpeed; 
        cruisingSpeed = (int) (Species.MaximumSpeed * .4); 
        Born += new BornEventHandler(BornEvent); 
        Load += new LoadEventHandler(LoadEvent); 
        Idle += new IdleEventHandler(IdleEvent); 
        Teleported += new TeleportedEventHandler(TeleportedEvent); 
        // the commented event handlers below are empty 
        // they are here to show you what is available 
        // ReproduceCompleted += new ReproduceCompletedEventHandler(ReproduceCompletedEvent); 
        // EatCompleted += new EatCompletedEventHandler(EatCompletedEvent); 
        DefendCompleted += new DefendCompletedEventHandler(DefendCompletedEvent); 
        Attacked += new AttackedEventHandler(AttackedEvent); 
        // AttackCompleted += new AttackCompletedEventHandler(AttackCompletedEvent); 
        MoveCompleted += new MoveCompletedEventHandler(MoveCompletedEvent); } 

    // *** User defined helper functions ********************************************** 
    // Tells you whether you have enough energy to move towards a given location at the given speed 
    // speed can be between 0 and Species.MaximumSpeed 
    bool CanMove(OrganismState target, int speed) { 
        return (State.EnergyRequiredToMove(DistanceTo(target), speed) < State.StoredEnergy); 
    } 
    // Starts moving towards the location at the given speed 
    void MoveToTarget(Point location, int speed) { 
        BeginMoving(new MovementVector(location, speed)); 
    } 
    // Finds creatures in the visible area and starts moving towards the first animal it finds 
    // A good strategy here would be to use the DistanceTo() function to find the closest creature 
    void ScanForTargetAnimal() { 
        ArrayList foundAnimals = Scan(); 
        if (foundAnimals.Count > 0) 
            foreach (OrganismState organismState in foundAnimals) 
                if (organismState is AnimalState) 
                    if (!IsMySpecies(organismState)) { 
                        targetAnimal = (AnimalState) organismState; 
                        MoveToTarget(targetAnimal.Position, huntingSpeed); 
                        return; 
                    } 
    }
    // *** Predefined event handlers ************************************************** 
    // Fired when we're first born 
    void BornEvent(object sender, BornEventArgs e) { 
        byte[] dna = e.Dna; 
        if (dna != null) { 
            // retrieve DNA info from the parent 
            MemoryStream m = new MemoryStream(dna); 
            BinaryReader b = new BinaryReader(m); 
            parentLocation = new Point(b.ReadInt32(), b.ReadInt32()); 
            b.Close(); 
            MoveToTarget(parentLocation, cruisingSpeed); 
            // start moving towards the parent 
        } 
    } 
    // First event fired on an organism each turn 
    void LoadEvent(object sender, LoadEventArgs e) { 
        // refresh and check targetAnimal just in case 
        if(targetAnimal != null) 
            targetAnimal = (AnimalState) LookFor(targetAnimal); 
        // targetAnimal could have disappeared due to death, teleportation, or error 
        if(targetAnimal == null) { 
            this.WriteTrace("Target animal disappeared."); 
            ScanForTargetAnimal(); 
        } 
    } 
    // Fired after all other events are fired during a turn 
    void IdleEvent(object sender, IdleEventArgs e) { 
        if(CanReproduce) { 
            // Reproduce as often as possible 
            // send "DNA" info to the offspring 
            MemoryStream m = new MemoryStream(); 
            BinaryWriter b = new BinaryWriter(m); 
            b.Write(State.Position.X); 
            b.Write(State.Position.Y); 
            BeginReproduction(m.ToArray()); 
            b.Close(); 
        } 
        if(IsAttacking || IsDefending || IsEating) 
            // busy 
            return; 
        if(IsMoving && targetAnimal != null) 
            // moving towards the target 
            return; 
        if (CanEat) { 
            this.WriteTrace("Hungry."); 
            if (targetAnimal != null) { 
                if (targetAnimal.IsAlive) { 
                    if (WithinAttackingRange(targetAnimal)) { 
                        this.WriteTrace("Live target within attack range. Attacking."); 
                        BeginAttacking(targetAnimal); 
                    } 
                    else { 
                        this.WriteTrace("Live target out of attack range. Moving closer."); 
                        MoveToTarget(targetAnimal.Position, huntingSpeed); 
                    } 
                } 
                else { 
                    if(WithinEatingRange(targetAnimal)) { 
                        this.WriteTrace("Dead target within eating range. Eating."); 
                        if(IsMoving) 
                            StopMoving(); 
                        BeginEating(targetAnimal); 
                    } 
                    else { 
                        this.WriteTrace("Dead target out of eathing range. Moving closer."); 
                        MoveToTarget(targetAnimal.Position, huntingSpeed); 
                    } 
                } 
            } 
            else { 
                if(!IsMoving) { 
                    this.WriteTrace("No target. Start Searching."); 
                    // move to a random location in search of food 
                    BeginMoving(new MovementVector(new Point(OrganismRandom.Next(0, WorldWidth - 1), OrganismRandom.Next(0, WorldHeight - 1)), cruisingSpeed)); 
                } 
                else { 
                    this.WriteTrace("No target. Already Searching."); 
                } 
            } 
        }
        else {
            this.WriteTrace("Full. Lazy."); 
            if(IsMoving) 
                StopMoving(); 
        } 
    } 
    // Fired if we got teleported 
    void TeleportedEvent(object sender, TeleportedEventArgs e) { 
        targetAnimal = null; 
    } 
    // Fired after we've given birth 
    void ReproduceCompletedEvent(object sender, ReproduceCompletedEventArgs e) { 
    } 
    // Fired after an eat action is completed 
    void EatCompletedEvent(object sender, EatCompletedEventArgs e) { 
    } 
    // Fired after a defend action is completed 
    void DefendCompletedEvent(object sender, DefendCompletedEventArgs e) { 
    } 
    // Fired if we're being attacked 
    void AttackedEvent(object sender, AttackedEventArgs e) { 
        AnimalState theAttacker = e.Attacker; 
        try { 
            if (theAttacker.IsAlive) { 
                // sanity check 
                this.WriteTrace("We're under attack!"); 
                if (!IsDefending) 
                    BeginDefending(theAttacker); 
                if (!IsAttacking) 
                    BeginAttacking(theAttacker); 
            } 
        } 
        catch (Exception ex) { 
            this.WriteTrace("AttackedEvent Exception: " + ex.ToString()); 
        } 
    } 
    // Fired if attack completed 
    void AttackCompletedEvent(object sender, AttackCompletedEventArgs e) { 
    } 
    // Fired if we arrived at our destination or got blocked 
    void MoveCompletedEvent(object sender, MoveCompletedEventArgs e) { 
        if (e.Reason == ReasonForStop.Blocked) { 
            if (e.BlockingOrganism is AnimalState) { 
                // this needs to be here because UpdateRadar may not see the blocker 
                // if the blocker is invisible we can assume he is harmless 
                AnimalState blockingAnimal = (AnimalState) e.BlockingOrganism; 
                if (blockingAnimal.IsAlive) { 
                    if (!IsMySpecies(blockingAnimal)) { 
                        if (WithinAttackingRange(blockingAnimal)) { 
                            this.WriteTrace("Blocking animal within attacking range. Attacking."); 
                            targetAnimal = blockingAnimal; 
                            BeginDefending(targetAnimal); 
                            BeginAttacking(targetAnimal); 
                        } 
                        else { 
                            this.WriteTrace("Blocking animal not in attacking range."); 
                            // insert code to pick an alternate route 
                        } 
                    } 
                    else { 
                        this.WriteTrace("MySpecies in the way."); 
                        // insert code to pick an alternate route 
                    } 
                } 
                else { 
                    this.WriteTrace("Blocking animal is dead. Free food!"); 
                    if (WithinEatingRange(blockingAnimal)) { 
                        if ((State.EnergyState < EnergyState.Full)) { 
                            // CanEat ? 
                            if (IsMoving) StopMoving(); targetAnimal = blockingAnimal; BeginEating(targetAnimal); 
                        } 
                        else { 
                            // I'm full. And lazy. 
                            if (IsMoving) StopMoving(); 
                        } 
                    } 
                    else { 
                        // move closer to the dead animal and eat it 
                        MoveToTarget(targetAnimal.Position, cruisingSpeed); 
                    } 
                } 
            } 
            else { 
                this.WriteTrace("Plant in the way."); 
                // insert code to pick an alternate route 
            } 
        } 
    } 
    // This gets called whenever your animal is being saved -- either the game is closing 
    // or you are being teleported. Store anything you want to remember when you are instantiated 
    // again in the stream. 
    public override void SerializeAnimal(MemoryStream m) { BinaryWriter b = new BinaryWriter(m); 
        if (targetAnimal != null) { 
            b.Write(true); b.Write(targetAnimal.ID); 
        } 
        else 
            b.Write(false); 
        if (parentLocation.X > -1) { 
            b.Write(true); 
            b.Write(parentLocation.X); 
            b.Write(parentLocation.Y); 
        } 
        else 
            b.Write(false); 
    } 
    // This gets called when you are instantiated again after being saved. You get a chance 
    // to pull out any information that you put into the stream when you were saved 
    public override void DeserializeAnimal(MemoryStream m) {
        BinaryReader b = new BinaryReader(m); 
        if (((bool) b.ReadBoolean())) 
            targetAnimal = (AnimalState) RefreshState(b.ReadString()); 
        if (((bool) b.ReadBoolean())) parentLocation = new Point(b.ReadInt32(), b.ReadInt32()); 
    }
}