View difference between Paste ID: P2RtFiP9 and xiGukYtp

-public class Behaviour
+using System;
 using System.Collections.Generic;
-    Item owner;
+using System.Linq;
 using System.Text;
-    public Behaviour()
+
 namespace Zeritor
-        // base class, does nothing.
+
     public class Behaviour
     {
-    public void Attach(Item item)
+        protected Item owner;
 
-        owner = item;
+        public Behaviour()
         {
-}
+            // base class, does nothing.
         }
-public class Harvestable : Behaviour()
+
         public void Attach(Item item)
-    public Harvestable()
+
             owner = item;
-        // This is just a base class so it doesn't do anything?
+
     }
 
-    public virtual void Harvest()
+    public class Harvestable : Behaviour
     {
-       // maybe log that the class was not set correctly
+        public Harvestable()
         {
-}
+            // This is just a base class so it doesn't do anything?
         }
-public class HarvestReplace : Harvestable
+
         public virtual void Harvest()
-    ItemType replaceType;
+
            // maybe log that the class was not set correctly
-    public HarvestReplace(ItemType replaceWith)
+
     }
-         this.replaceType = replaceWith;
+
     public class HarvestReplace : Harvestable
     {
-    public override void Harvest()
+        ItemRecipe replaceWith;
 
-        owner.Remove();
+        public HarvestReplace(ItemRecipe replaceWith)
-        owner.World.AddItem(replaceType);
+
              this.replaceWith = replaceWith;
-}
+
 
-public class ItemType
+        public override void Harvest()
         {
-    someVar someProperty;
+            owner.World.Remove(owner);
-    List<Behaviour> behaviours;
+
             // You'll probably need to extend this logic so the Harvestable can update his replaceWith recipe
-    public ItemType(ushort id)
+            // to take the Harvestable's position.
             owner.World.AddItem(replaceWith);
-        // EXAMPLE if it was a tree, in reality there's a load of different types here.
+
-        ItemType tree = new ItemType;
+
-        tree.someProperty = someValue;
+
-        tree.behaviours = new List<Behaviour>();
+    public class World
-        tree.behaviours.Add(new HarvestReplace(ItemTypes.Log);
+
         List<Item> worldItems = new List<Item>();
-}
+        List<Item> addList = new List<Item>();
         List<Item> removeList = new List<Item>();
-public class Item
+
         public void Remove( Item removeMe )
-    World world;
+
-    someVar someProperty;
+            // Remove me (probably put me on a delete list to remove next frame and set a flag on my ass
-    Harvestable harvestable;
+            // so no one goes using me)
 
-    public Item(World parent, ItemType type, Vector3 position
+            removeList.Add(removeMe);
         }
-        // Get all the basics
+
-        world = parent;
+        public Item AddItem( ItemRecipe recipe )
-        this.someProperty = type.property;
+
             Item retVal = new Item(this, recipe);
-        // now assign behaviours from type
+            addList.Add(retVal);
-        // Uh this won't actually work with multiple objects as you're assigning an object reference
+            return retVal;
-        // I.e: Create TreeA then TreeB and Harvest TreeA, TreeB will get deleted.
+
-        foreach(Behaviour behaviour in type.behaviours)
+
         public void Update()
-            behaviour.Attach(this);
+
-            if(behaviour is Harvestable)
+            // Add from addList
             worldItems.AddRange(addList);
-                this.harvestable = behaviour;
+            addList.Clear();
 
             // Purge from removeList
-
+            // There's a linq version of this that is rad, but I won't
             // Obfuscate here
             foreach (var item in removeList)
             {
                 worldItems.Remove(item);
                 // Do item cleanup
             }
 
             removeList.Clear();
 
             foreach (var item in worldItems)
             {
                 // Do a generic update.
             }
         }
 
         // This is for illustrative purposes to see how you'd get to the Harvestable behavior from an arbitrary item
         public void CrazyAssTempFunctionToHarvestAllHarvestables()
         {
             foreach (var item in worldItems)
             {
                 Harvestable har = item.GetBehavior<Harvestable>();
                 if (har != null)
                 {
                     har.Harvest();
                 }
             }
         }
     }
 
     public abstract class ItemRecipe
     {
         abstract public List<Behaviour> CreateBehaviors();
     }
 
     public class Item
     {
         World world;
         Dictionary<Type, Behaviour> behaviours = new Dictionary<Type, Behaviour>();
 
         public World World
         {
             get
             {
                 return world;
             }
         }
 
         public Item(World parent, ItemRecipe recipe)
         {
             // Get all the basics
             world = parent;
             List<Behaviour> initBehaviours = recipe.CreateBehaviors();
 
             foreach (var beh in initBehaviours)
             {
                 beh.Attach(this);
                 // Get this behavior's type that is immediately inherited from Behavior
                 // ie, we want to browse for behaviours like Harvestable,
                 // NOT SPECIFIC BEHAVIOURS LIKE HARVESTABLE REPLACE
                 Type installType = beh.GetType();
                 Type baseType = installType.BaseType;
                 while (baseType != typeof(Behaviour))
                 {
                     installType = baseType;
                     baseType = installType.BaseType;
                 }
 
                 behaviours[installType] = beh;
             }
         }
 
         public T GetBehavior<T>() where T : class
         {
             Behaviour returnVal = null;
             if (behaviours.TryGetValue(typeof(T), out returnVal))
             {
                 return returnVal as T;
             }
 
             return null;
         }
     }
 
     public class WoodRecipe : ItemRecipe
     {
         override public List<Behaviour> CreateBehaviors()
         {
             // Fill this out with whatever behaviors wood is supposed to have
             return new List<Behaviour>();
         }
     }
 
     public class TreeRecipe : ItemRecipe
     {
         override public List<Behaviour> CreateBehaviors()
         {
             List<Behaviour> retVal = new List<Behaviour>();
             retVal.Add(new HarvestReplace(new WoodRecipe()));
 
             return retVal;
         }
     }
 
     class Program
     {
         static void Main(string[] args)
         {
 
             World myWorld = new World();
             myWorld.AddItem(new TreeRecipe());
 
             while (true)
             {
                 myWorld.Update();
                 myWorld.CrazyAssTempFunctionToHarvestAllHarvestables();
             }
         }
     }
 }