diff --git a/Core/include/Core/Tile.hpp b/Core/include/Core/Tile.hpp
index 15c9a97..935e897 100644
--- a/Core/include/Core/Tile.hpp
+++ b/Core/include/Core/Tile.hpp
@@ -105,8 +105,16 @@ namespace CaveGame::Core {
         uint8_t g;
     };
 
-    /*
-    class Tile
+    class TestTile;
+
+    class TileTrait {
+    public:
+        virtual void Invoke(ITileMap* world, int x, int y) {};
+    };
+
+    // Tile trait code to be fully implemented
+    /*//////////////////////////////////////////////////////////////////////////////*/
+    class TestTile
     {
     public:
         TileID numeric_id = TileID::VOID;
@@ -114,17 +122,80 @@ namespace CaveGame::Core {
     public:
         Color4 base_color;
         std::vector<Color4> color_pallet;
-        TileFlags flags = NonSolid;
+        //TileFlags flags = NonSolid;
     public:
-        TileID NumericID();
-        std::string MnemonicID();
-        TileFlags Flags();
-        bool HasFlag(TileFlags f);
+        TestTile(TileID id, std::string mnemonic);
+        TileID NumericID() { return numeric_id; }
+        std::string MnemonicID() { return mnemonic_id; }
+        /*
+        bool HasTrait(TileTrait* tr) {
+            Tile* d;
+            if (Tile* d = dynamic_cast<Tile*>(tr); d != nullptr) {
+                return true;
+            }
+            return false;
+        }
+         */
+        //TileFlags Flags();
+        //bool HasFlag(TileFlags f);
+        virtual void InvokeTraits(ITileMap* world, int x, int y) {};
+    };
 
+    class Ticker : public TileTrait {};
+    class RandomTicker : public Ticker {};
+    class ForcedTicker : public Ticker {};
 
+    class OnCondition : public TileTrait
+    {
+    public:
+        OnCondition();
+        virtual bool Condition(ITileMap* world, int x, int y) { return true; }
+        virtual void Perform(ITileMap* world, int x, int y) {}
+        virtual void Invoke(ITileMap* world, int x, int y) override {
+            if (Condition(world, x, y))
+                Perform(world, x, y);
+        }
+    };
 
+    class DecayTo : public OnCondition
+    {
+    public:
+        TestTile* dt;
+    public:
+        DecayTo(TestTile* dt) : OnCondition(), dt(dt) {};
+        virtual bool Condition(ITileMap* world, int x, int y) override { return true; }
+        virtual void Perform(ITileMap* world, int x, int y) override {
+            world->SetTile(x, y, dt->NumericID());
+        }
+    };
+
+    class Spreader : public OnCondition
+    {
+    public:
+        TestTile* st;
+    public:
+        Spreader(TestTile* st) : OnCondition(), st(st) {};
+        virtual bool Condition(ITileMap* world, int x, int y) override {
+            return (world->GetTile(x, y) == st->NumericID()) && world->HasAdjacentOrDiagonalAirBlock(x, y);
+        }
+        virtual void Perform(ITileMap* world, int x, int y) override {
+            world->SetTile(x, y, st->NumericID());
+        }
+    };
+
+    /*
+    class Suffocator : public TileTrait
+    {
+    public:
+        Suffocator() : TileTrait() {};
+    public:
+        virtual void Invoke(ITileMap* world, int x, int y) override {
+            if (!world->HasAdjacentOrDiagonalAirBlock(x, y))
+                return true;
+            return false;
+        }
     };*/
-
+    /*//////////////////////////////////////////////////////////////////////////////*/
 
     class TileGroup {};