using System;
using System.Drawing;
using System.Collections;
using System.IO;
using OrganismBase;

// Sample Carnivore
// Strategy: This animal stands still until it sees something tasty and then
// bites it.  If any dead animals are within range it eats them.

// The following Assembly attributes must be applied to each Organism Assembly
// The class that derives from Animal
[assembly: OrganismClass("CSharpCreatures.SimpleCarnivore")]
// Provide Author Information
// Author Name, Email
[assembly: AuthorInformation("Your Name", "someone@microsoft.com")]

namespace CSharpCreatures 
{
    // It's an herbivore
    [CarnivoreAttribute(true)]
    // This value must be between 24 and 48, 24 means faster reproduction
    // while 48 would give more defense and attack power
    // Make it smaller for reproduction, but not too small
    [MatureSize(30)]

    // AnimalSkin = AnimalSkinFamilyEnum.Scorpion, you can be a Beetle
    // an Ant, a Scorpion, an Inchworm, or a Spider
    // MarkingColor = KnownColor.Red, you can choose to mark your
    // creature with a color.  This does not affect appearance in
    // the game.
    [AnimalSkin(AnimalSkinFamily.Beetle)]
    [MarkingColor(KnownColor.Red)]

    // Point Based Attributes
    // You get 100 points to distribute among these attributes to define
    // what your organism can do.  Choose them based on the strategy your organism
    // will use.  This organism stays still and waits for creatures to come.
    [MaximumEnergyPoints(0)]        // No need to store energy.
    [EatingSpeedPoints(0)]          // No need to eat fast.
    [AttackDamagePoints(52)]        // Needs to deal some good damage
    [DefendDamagePoints(0)]         // Attacks, so no need for defense
    [MaximumSpeedPoints(28)]        // Moves somewhat fast to catch prey
    [CamouflagePoints(0)]           // Doesn't mind if noticed
    [EyesightPoints(20)]            // Needs to see prey and food

    public class SimpleCarnivore : Animal 
    {
        AnimalState targetAnimal;

        protected override void Initialize() 
        {
            Load += new LoadEventHandler(LoadEvent);
            Idle += new IdleEventHandler(IdleEvent);
        }

        // First event fired on an organism each turn
        void LoadEvent(object sender, LoadEventArgs e)
        {
            try 
            {
                if(targetAnimal != null) 
                {
                    // See if our target animal still exists (it may have died)
                    // LookFor returns null if it isn't found
                    targetAnimal = (AnimalState) LookFor(targetAnimal);
                }
            }
            catch(Exception exc) 
            {
                // WriteTrace is useful in debugging creatures
                WriteTrace(exc.ToString());
            }
        }

        // Fired after all other events are fired during a turn
        void IdleEvent(object sender, IdleEventArgs e) 
        {
            try 
            {
                // Our Creature will reproduce as often as possible so
                // every turn it checks CanReproduce to know when it
                // is capable.  If so we call BeginReproduction with
                // a null Dna parameter to being reproduction.
                if(CanReproduce)
                    BeginReproduction(null);

                // If we are already doing something, then we don't
                // need to do something else.  Lets leave the
                // function.
                if ( IsAttacking || IsMoving || IsEating ) 
                {
                    return;
                }

                // Try to find a new target if we need one.
                if(targetAnimal == null) 
                {
                    FindNewTarget();
                } 

                // If we have a target animal then lets check him out
                if(targetAnimal != null ) 
                {
                    // If the target is alive, then we need to kill it
                    // else we can immediately eat it.
                    if ( targetAnimal.IsAlive ) 
                    {
                        // If we are within attacking range, then
                        // lets eat the creature.  Else we'll
                        // try to move into range
                        if ( WithinAttackingRange(targetAnimal) ) 
                        {
                            BeginAttacking(targetAnimal);
                        } 
                        else 
                        {
                            MoveToTarget();
                        }
                    } 
                    else 
                    {
                        // If the creature is dead then we can try to eat it.
                        // If we are within eating range then we'll try to
                        // eat the creature, else we'll move towards it.
                        if ( WithinEatingRange(targetAnimal) ) 
                        {
                            if (CanEat) 
                            {
                                BeginEating(targetAnimal);
                            } 
                        } 
                        else 
                        {
                            MoveToTarget();
                        }
                    }
                } 
                else 
                {
                    // If we stop moving we conserve energy.  Sometimes
                    // this works better than running around.
                    StopMoving();
                }
            } 
            catch(Exception exc) 
            {
                WriteTrace(exc.ToString());
            }
        }

        void FindNewTarget() 
        {
            try 
            {
                ArrayList foundAnimals = Scan();

                // We should see at least a couple of animals.
                if(foundAnimals.Count > 0) 
                {
                    foreach(OrganismState organismState in foundAnimals) 
                    {
                        // We are looking for any organism that is an animal
                        // and that isn't of our species so we can eat them.
                        if(organismState is AnimalState && !IsMySpecies(organismState)) 
                        {
                            targetAnimal = (AnimalState) organismState;
                        }
                    }
                }
            }
            catch(Exception exc) 
            {
                WriteTrace(exc.ToString());
            }
        }

        // Function used to move towards our prey or meal
        void MoveToTarget() 
        {
            try 
            {
                // Make sure we aren't moving towards a null target
                if ( targetAnimal == null ) 
                {
                    return;
                }

                // Follow our target as quickly as we can
                BeginMoving(new MovementVector(targetAnimal.Position, Species.MaximumSpeed));
            }
            catch(Exception exc) 
            {
                WriteTrace(exc.ToString());
            }
        }

        // 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) 
        {
        }

        // 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) 
        {
        }
    }
}

Imports System
Imports System.Drawing
Imports System.Collections
Imports System.IO
Imports OrganismBase

' Sample Carnivore
' Strategy: This animal stands still until it sees something tasty and then
' bites it.  If any dead animals are within range it eats them.

' The following Assembly attributes must be applied to each Organism Assembly
' The class that derives from Animal

' Provide Author Information
' Author Name, Email


Namespace VBCreatures
    ' Carnivore = True, It's a Carnivore
    ' MatureSize = 30, Must be between 24 and 48, 24 means faster
    ' reproduction while 48 would give more defense and attack power
    '
    ' AnimalSkin = AnimalSkinFamilyEnum.Scorpion, you can be a Beetle
    ' an Ant, a Scorpion, an Inchworm, or a Spider
    ' MarkingColor = KnownColor.Red, you can choose to mark your
    ' creature with a color.  This does not affect appearance in
    ' the game.
    '
    ' Point Based Attributes
    ' You get 100 points to distribute among these attributes to define
    ' what your organism can do.  Choose them based on the strategy
    ' your organism will use.  This organism hides and has good eyesight
    ' to find plants.
    '
    ' MaximumEnergyPoints = 0, No need to store energy.
    ' EatingSpeedPoints = 0, No need to eat fast.
    ' AttackDamagePoints = 52, Needs to deal some good damage
    ' DefendDamagePoints = 0, Attacks, so no need for defense
    ' MaximumSpeedPoints = 28, Moves somewhat fast to catch prey
    ' CamouflagePoints = 0, Doesn't mind if noticed
    ' EyesightPoints = 20, Needs to see prey and food
    < _
        CarnivoreAttribute(True), _
        MatureSize(30), _
        AnimalSkin(AnimalSkinFamily.Beetle), _
        MarkingColor(KnownColor.Red), _
        MaximumEnergyPoints(0), _
        EatingSpeedPoints(0), _
        AttackDamagePoints(52), _
        DefendDamagePoints(0), _
        MaximumSpeedPoints(28), _
        CamouflagePoints(0), _
        EyesightPoints(20) _
    > _
    Public Class SimpleCarnivore : Inherits Animal
        Dim targetAnimal As AnimalState

        Protected Overloads Overrides Sub Initialize()
            AddHandler Load, New LoadEventHandler(AddressOf LoadEvent)
            AddHandler Idle, New IdleEventHandler(AddressOf IdleEvent)
        End Sub

        ' First event fired on an organism each turn
        Private Sub LoadEvent(ByVal Sender As Object, ByVal e As LoadEventArgs)
            Try
                If Not targetAnimal Is Nothing Then
                    ' See if our target animal still exists (it may have died)
                    ' LookFor returns null if it isn't found
                    targetAnimal = CType(LookFor(targetAnimal), AnimalState)
                End If
            Catch exc As Exception
                ' WriteTrace is useful in debugging creatures
                WriteTrace(exc.ToString())
            End Try
        End Sub

        ' Fired after all other events are fired during a turn
        Private Sub IdleEvent(ByVal Sender As Object, ByVal e As IdleEventArgs)
            Try
                ' Our Creature will reproduce as often as possible so
                ' every turn it checks CanReproduce to know when it
                ' is capable.  If so we call BeginReproduction with
                ' a null Dna parameter to being reproduction.
                If CanReproduce Then
                    BeginReproduction(Nothing)
                End If

                ' If we are already doing something, then we don't
                ' need to do something else.  Lets leave the
                ' function.
                If IsAttacking Or IsMoving Or IsEating Then
                    Return
                End If

                ' Try to find a new target if we need one.
                If targetAnimal Is Nothing Then
                    FindNewTarget()
                End If

                ' If we have a target animal then lets check him out
                If Not targetAnimal Is Nothing Then
                    ' If the target is alive, then we need to kill it
                    ' else we can immediately eat it.
                    If targetAnimal.IsAlive Then
                        ' If we are within attacking range, then
                        ' lets eat the creature.  Else we'll
                        ' try to move into range
                        If WithinAttackingRange(targetAnimal) Then
                            BeginAttacking(targetAnimal)
                        Else
                            MoveToTarget()
                        End If
                    Else
                        ' If the creature is dead then we can try to eat it.
                        ' If we are within eating range then we'll try to
                        ' eat the creature, else we'll move towards it.
                        If WithinEatingRange(targetAnimal) Then
                            If CanEat Then
                                BeginEating(targetAnimal)
                            End If
                        Else
                            MoveToTarget()
                        End If
                    End If
                Else
                    ' If we stop moving we conserve energy.  Sometimes
                    ' this works better than running around.
                    StopMoving()
                End If
            Catch exc As Exception
                WriteTrace(exc.ToString())
            End Try
        End Sub


        Private Sub FindNewTarget()
            Try
                Dim foundAnimals As ArrayList = Scan()

                ' We should see at least a couple of animals.
                If foundAnimals.Count > 0 Then
                    Dim orgState As OrganismState
                    For Each orgState In foundAnimals
                        ' We are looking for any organism that is an animal
                        ' and that isn't of our species so we can eat them.
                        If TypeOf orgState Is AnimalState And Not IsMySpecies(orgState) Then
                            targetAnimal = CType(orgState, AnimalState)
                        End If
                    Next
                End If
            Catch exc As Exception
                WriteTrace(exc.ToString())
            End Try
        End Sub

        ' Function used to move towards our prey or meal
        Private Sub MoveToTarget()
            Try
                ' Make sure we aren't moving towards a null target
                If targetAnimal Is Nothing Then
                    Return
                End If

                ' Follow our target as quickly as we can
                BeginMoving(New MovementVector(targetAnimal.Position, Species.MaximumSpeed))
            Catch exc As Exception
                WriteTrace(exc.ToString())
            End Try
        End Sub

        ' 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 Overloads Overrides Sub SerializeAnimal(ByVal m As MemoryStream)
        End Sub

        ' 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 Overloads Overrides Sub DeserializeAnimal(ByVal m As MemoryStream)
        End Sub
    End Class
End Namespace

using System;
using System.Drawing;
using System.Collections;
using System.IO;
using OrganismBase;

// Sample Herbivore
// Strategy: This animal moves until it finds a food source and then stays there

// The following Assembly attributes must be applied to each Organism Assembly
[assembly: OrganismClass("CSharpCreatures.SimpleHerbivore")]    // The class that derives from Animal
[assembly: AuthorInformation("Your Name", "someone@microsoft.com")] // Provide Author Information
                                                                // Author Name, Email
namespace CSharpCreatures 
{
    // It's an herbivore
    [CarnivoreAttribute(false)]
    // This value must be between 24 and 48, 24 means faster reproduction
    // while 48 would give more defense and attack power
    // Make it smaller for reproduction
    [MatureSize(26)]

    // AnimalSkin = AnimalSkinFamilyEnum.Beetle, you can be a Beetle
    // an Ant, a Scorpion, an Inchworm, or a Spider
    // MarkingColor = KnownColor.Red, you can choose to mark your
    // creature with a color.  This does not affect appearance in
    // the game.
    [AnimalSkin(AnimalSkinFamily.Beetle)]
    [MarkingColor(KnownColor.Red)]

    // Point Based Attributes
    // You get 100 points to distribute among these attributes to define
    // what your organism can do.  Choose them based on the strategy your organism
    // will use.  This organism hides and has good eyesight to find plants.
    [MaximumEnergyPoints(0)]    // Don't need to increase this as it just sits next to plants
    [EatingSpeedPoints(0)]      // Ditto
    [AttackDamagePoints(0)]     // Doesn't ever attack
    [DefendDamagePoints(0)]     // Doesn't even defend
    [MaximumSpeedPoints(0)]     // Doesn't need to move quickly
    [CamouflagePoints(50)]      // Try to remain hidden
    [EyesightPoints(50)]        // Need this to find plants better

    public class SimpleHerbivore : Animal 
    {
        PlantState targetPlant = null;  // The current plant we're going after

        // Set up any event handlers that we want when first initialized
        protected override void Initialize() 
        {
            Load += new LoadEventHandler(LoadEvent);
            Idle += new IdleEventHandler(IdleEvent);
        }

        // First event fired on an organism each turn
        void LoadEvent(object sender, LoadEventArgs e) 
        {
            try
            {
                if(targetPlant != null) 
                {
                    // See if our target plant still exists (it may have died)
                    // LookFor returns null if it isn't found
                    targetPlant = (PlantState) LookFor(targetPlant);
                }
            }
            catch(Exception exc) 
            {
                // WriteTrace is useful in debugging creatures
                WriteTrace(exc.ToString());
            }
        }

        // Fired after all other events are fired during a turn
        void IdleEvent(object sender, IdleEventArgs e) 
        {
            try
            {
                // Our Creature will reproduce as often as possible so
                // every turn it checks CanReproduce to know when it
                // is capable.  If so we call BeginReproduction with
                // a null Dna parameter to being reproduction.
                if(CanReproduce)
                    BeginReproduction(null);

                // Check to see if we are capable of eating
                // If we are then try to eat or find food,
                // else we'll just stop moving.
                if(CanEat && !IsEating) 
                {
                    // If we have a Target Plant we can try
                    // to either eat it, or move towards it.
                    // else we'll move to a random vector
                    // in search of a plant.
                    if(targetPlant != null) 
                    {
                        // If we are within range start eating
                        // and stop moving.  Else we'll try
                        // to move towards the plant.
                        if(WithinEatingRange(targetPlant)) 
                        {
                            BeginEating(targetPlant);
                            if(IsMoving) 
                                StopMoving();
                        }
                        else 
                        {
                            if(!IsMoving) 
                                BeginMoving(new MovementVector(targetPlant.Position, 2));
                        }
                    }
                    else 
                    {
                        // We'll try try to find a target plant
                        // If we don't find one we'll move to 
                        // a random vector
                        if(!ScanForTargetPlant()) 
                        {
                            if(!IsMoving) 
                            {
                                int RandomX= OrganismRandom.Next(0, WorldWidth - 1);
                                int RandomY= OrganismRandom.Next(0, WorldHeight - 1);
                                BeginMoving(new MovementVector(new Point(RandomX,RandomY), 2));
                            }
                        }
                    }
                }
                else 
                {
                    // Since we are Full or we are already eating
                    // We should stop moving.
                    if(IsMoving)
                        StopMoving();
                }
            }
            catch(Exception exc) 
            {
                WriteTrace(exc.ToString());
            }
        }

        // Looks for target plants, and starts moving towards the first one it finds
        bool ScanForTargetPlant() 
        {
            try
            {
                // Find all Plants/Animals in range
                ArrayList foundAnimals = Scan();

                // If we found some Plants/Animals lets try
                // to weed out the plants.
                if(foundAnimals.Count > 0) 
                {
                    foreach(OrganismState organismState in foundAnimals) 
                    {
                        // If we found a plant, set it as our target
                        // then begin moving towards it.  Tell the
                        // caller we have a target.
                        if(organismState is PlantState) 
                        {
                            targetPlant = (PlantState) organismState;
                            BeginMoving(new MovementVector(organismState.Position, 2));
                            return true;
                        }
                    }
                }
            }
            catch(Exception exc) 
            {
                WriteTrace(exc.ToString());
            }

            // Tell the caller we couldn't find a target
            return false;
        }

        // 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) 
        {
        }

        // 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) 
        {
        }
    }
}

Imports System
Imports System.Drawing
Imports System.Collections
Imports System.IO
Imports OrganismBase

' Sample Herbivore
' Strategy: This animal moves until it finds a food source and then stays there

' The following Assembly attributes must be applied to each Organism Assembly
' The class that derives from Animal
 
' Provide Author Information
' Author Name, Email
 

Namespace VBCreatures
    ' Carnivore = False, It's a Herbivore
    ' MatureSize = 26, Must be between 24 and 48, 24 means faster
    ' reproduction while 48 would give more defense and attack power
    '
    ' AnimalSkin = AnimalSkinFamilyEnum.Beetle, you can be a Beetle
    ' an Ant, a Scorpion, an Inchworm, or a Spider
    ' MarkingColor = KnownColor.Red, you can choose to mark your
    ' creature with a color.  This does not affect appearance in
    ' the game.
    '
    ' Point Based Attributes
    ' You get 100 points to distribute among these attributes to define
    ' what your organism can do.  Choose them based on the strategy
    ' your organism will use.  This organism hides and has good eyesight
    ' to find plants.
    '
    ' MaximumEnergyPoints = 0, Sits next to plants, doesn't need an energy store
    ' EatingSpeedPoints = 0, Sits next to plants, doesn't need faster eating speed
    ' AttackDamagePoints = 0, Doesn't ever attack
    ' DefendDamagePoints = 0, Doesn't ever defend
    ' MaximumSpeedPoints = 0, Doesn't need to move quickly
    ' CamouflagePoints = 50, Try to remain hidden
    ' EyesightPoints = 50, Need to find plants better
    < _
        Carnivore(False), _
        MatureSize(26), _
        AnimalSkin(AnimalSkinFamily.Beetle), _
        MarkingColor(KnownColor.Red), _
        MaximumEnergyPoints(0), _
        EatingSpeedPointsAttribute(0), _
        AttackDamagePointsAttribute(0), _
        DefendDamagePointsAttribute(0), _
        MaximumSpeedPointsAttribute(0), _
        CamouflagePointsAttribute(50), _
        EyesightPointsAttribute(50) _
    > _
    Public Class SimpleHerbivore : Inherits Animal
        ' Our Current Target Plant
        Dim targetPlant As PlantState = Nothing

        ' Set up any event handlers that we want when first initialized
        Protected Overloads Overrides Sub Initialize()
            AddHandler Load, New LoadEventHandler(AddressOf LoadEvent)
            AddHandler Idle, New IdleEventHandler(AddressOf IdleEvent)
        End Sub

        ' First event fired on an organism each turn
        Private Sub LoadEvent(ByVal Sender As Object, ByVal e As LoadEventArgs)
            Try
                If Not targetPlant Is Nothing Then
                    ' See if our target plant still exists (it may have died)
                    ' LookFor returns null if it isn't found
                    targetPlant = CType(LookFor(targetPlant), PlantState)
                End If
            Catch exc As Exception
                ' WriteTrace is useful in debugging creatures
                WriteTrace(exc.ToString())
            End Try
        End Sub

        ' Fired after all other events are fired during a turn
        Private Sub IdleEvent(ByVal Sender As Object, ByVal e As IdleEventArgs)
            Try
                ' Our Creature will reproduce as often as possible so
                ' every turn it checks CanReproduce to know when it
                ' is capable.  If so we call BeginReproduction with
                ' a null Dna parameter to being reproduction.
                If CanReproduce Then
                    BeginReproduction(Nothing)
                End If

                ' Check to see if we are capable of eating
                ' If we are then try to eat or find food,
                ' else we'll just stop moving.
                If CanEat And Not IsEating Then
                    ' If we have a Target Plant we can try
                    ' to either eat it, or move towards it.
                    ' else we'll move to a random vector
                    ' in search of a plant.
                    If Not targetPlant Is Nothing Then
                        ' If we are within range start eating
                        ' and stop moving.  Else we'll try
                        ' to move towards the plant.
                        If WithinEatingRange(targetPlant) Then
                            BeginEating(targetPlant)
                            If (IsMoving) Then
                                StopMoving()
                            End If
                        Else
                            If Not IsMoving Then
                                BeginMoving(New MovementVector(targetPlant.Position, 2))
                            End If
                        End If
                    Else
                        ' We'll try try to find a target plant
                        ' If we don't find one we'll move to 
                        ' a random vector
                        If Not ScanForTargetPlant() Then
                            If Not IsMoving Then
                                Dim RandomX As Integer = OrganismRandom.Next(0, WorldWidth - 1)
                                Dim RandomY As Integer = OrganismRandom.Next(0, WorldHeight - 1)
                                BeginMoving(New MovementVector(New Point(RandomX, RandomY), 2))
                            End If
                        End If
                    End If
                Else
                    ' Since we are Full or we are already eating
                    ' We should stop moving.
                    If (IsMoving) Then
                        StopMoving()
                    End If
                End If
            Catch exc As Exception
                WriteTrace(exc.ToString())
            End Try
        End Sub

        'Looks for target plants, and starts moving towards the first one it finds
        Private Function ScanForTargetPlant() As Boolean
            Try
                ' Find all Plants/Animals in range
                Dim foundAnimals As ArrayList = Scan()

                ' If we found some Plants/Animals lets try
                ' to weed out the plants.
                If foundAnimals.Count > 0 Then
                    Dim orgState As OrganismState

                    For Each orgState In foundAnimals
                        ' If we found a plant, set it as our target
                        ' then begin moving towards it.  Tell the
                        ' caller we have a target.
                        If TypeOf orgState Is PlantState Then
                            targetPlant = CType(orgState, PlantState)
                            BeginMoving(New MovementVector(orgState.Position, 2))
                            Return True
                        End If
                    Next
                End If
            Catch exc As Exception
                WriteTrace(exc.ToString())
            End Try

            ' Tell the caller we couldn't find a target
            Return False
        End Function

        ' 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 Overloads Overrides Sub SerializeAnimal(ByVal m As MemoryStream)
        End Sub

        '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 Overloads Overrides Sub DeserializeAnimal(ByVal m As MemoryStream)
        End Sub
    End Class
End Namespace

using System.IO;
using OrganismBase;

// Sample Plant

// The following Assembly attributes must be applied to each Organism Assembly 
[assembly: OrganismClass("CSharpCreatures.Plant2")]
// The class that derives from Animal 

[assembly: AuthorInformation("Your Name", "someone@microsoft.com")]
// Provide Author Information 
// Author Name, Email 

namespace CSharpCreatures
{
    //The definition of a plant is relatively easy since plants do not have to have any sort of
    //movement defined to allow them to locate sources of food. 
    //Each plant has three basic functions: 
    //1. Grow 
    //2. Reproduce by spreading seeds 
    //3. Be eaten by herbivores 
    //
    //A plant organism does not need to contain any methods, it just has three properties that
    //define how a plant functions.
    //1. The “MaximumEnergyPoints” property allows the developer to state how many energy points
    //   a herbivore will gain by consuming this plant. The maximum allowed is 10. 
    //2. The “MatureSize” property which must be a number between 24 and 48 states the maximum
    //   size a plant can grow to when it has survived for some amount of time without being consumed.
    //   The smaller a plant is, the faster it will be able to reproduce. As a plant gets larger it will
    //   become easier for herbivores to see and will more likely be consumed. 
    //3. The “SeedSpreadDistanceAttribute” states the maximum distance a plant can spread seeds
    //   from its current location. The maximum allowed is 100. These three properties alone are enough
    //   to define a functioning plant for the Terrarium game. 
    //   This value must be between 26 and 48, 26 means faster reproduction 
    //   while 48 would give more defense and attack power 
    //   Make it smaller for reproduction 
    [MaximumEnergyPoints(10)]
    [MatureSize(26)]
    [SeedSpreadDistance(100)]
    public class Plant2 : Plant
    {
        // 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 SerializePlant(MemoryStream m) { }
        // 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 DeserializePlant(MemoryStream m) { }
    }
}

Imports System.IO
Imports OrganismBase

' Sample Plant

Namespace VBCreatures
    ' The following Assembly attributes must be applied to each Organism Assembly
    ' The class that derives from Animal

    'The definition of a plant is relatively easy since plants do not have to have any sort of
    'movement defined to allow them to locate sources of food. 
    'Each plant has three basic functions: 
    '1. Grow 
    '2. Reproduce by spreading seeds 
    '3. Be eaten by herbivores 
    '
    'A plant organism does not need to contain any methods, it just has three properties that
    'define how a plant functions.
    '1. The “MaximumEnergyPoints” property allows the developer to state how many energy points
    //   a herbivore will gain by consuming this plant. The maximum allowed is 10. 
    '2. The “MatureSize” property which must be a number between 24 and 48 states the maximum
    '   size a plant can grow to when it has survived for some amount of time without being consumed.
    '   The smaller a plant is, the faster it will be able to reproduce. As a plant gets larger it will
    '   become easier for herbivores to see and will more likely be consumed. 
    '3. The “SeedSpreadDistanceAttribute” states the maximum distance a plant can spread seeds
    '   from its current location. The maximum allowed is 100. These three properties alone are enough
    '   to define a functioning plant for the Terrarium game. 
    '   This value must be between 26 and 48, 26 means faster reproduction 
    '   while 48 would give more defense and attack power 
    '   Make it smaller for reproduction 
    < _
        MaximumEnergyPoints(10), _
        MatureSize(25), _
        SeedSpreadDistance(65) _
    > _
    Public Class Plant2 : Inherits Plant

        ' 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 Overloads Overrides Sub SerializeAnimal(ByVal m As MemoryStream)
        End Sub

        ' 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 Overloads Overrides Sub DeserializeAnimal(ByVal m As MemoryStream)
        End Sub
    End Class
End Namespace