public static void mine(Terrain terrain, int x, int y, Quinoa quinoa)
        {
            switch(terrain.getCode())
            {
                case TerrainCode.ROCK:
                terrain.setCode(TerrainCode.STONE_FLOOR);

                if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_MINERALS))
                {
                    int mineralCode = Int32.Parse(TerrainManager.getParameter(terrain, TerrainParameter.HAS_MINERALS));
                    switch(mineralCode)
                    {
                        case 1:
                        if(RandomNumber.RandomDouble() > 0.5)
                        {
                            Item gem = new Item();
                            gem.itemClass = ItemClass.AMETHYST;
                            gem.setPosition(x, y);
                            quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
                        }
                        else
                        {
                            //do nothing
                        }
                        break;

                        case 2:
                        if(RandomNumber.RandomDouble() > 0.5)
                        {
                            Item gem = new Item();
                            gem.itemClass = ItemClass.SAPPHIRE;
                            gem.setPosition(x, y);
                            quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
                        }
                        else
                        {
                            Item gem = new Item();
                            gem.itemClass = ItemClass.EMERALD;
                            gem.setPosition(x, y);
                            quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
                        }
                        break;

                        case 3:
                        if(RandomNumber.RandomDouble() > 0.33)
                        {
                            Item gem = new Item();
                            gem.itemClass = ItemClass.RUBY;
                            gem.setPosition(x, y);
                            quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
                        }
                        else
                        {
                            Item gem = new Item();
                            gem.itemClass = ItemClass.DIAMOND;
                            gem.setPosition(x, y);
                            quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
                        }
                        break;

                    }
                }

                break;

                case TerrainCode.STONE_FLOOR:
                terrain.setCode(TerrainCode.STREAM_BED);
                break;

                case TerrainCode.STREAM_BED:
                if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_DRAIN))
                {
                    terrain.getParameters().Remove(TerrainParameter.HAS_DRAIN);
                }
                else
                {
                    terrain.getParameters().Add(TerrainParameter.HAS_DRAIN, TerrainManager.DRAIN_RATE+"");
                }
                break;

                default:
                //do nothing
                break;
            }
        }
        public static void dig(Terrain terrain, int x, int y, Quinoa quinoa)
        {
            //check for graves
            if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_GRAVE))
            {
                GraveCode gc = (GraveCode)Enum.Parse(typeof(GraveCode), TerrainManager.getParameter(terrain, TerrainParameter.HAS_GRAVE));
                if(gc == GraveCode.NORMAL && RandomNumber.RandomDouble() < TerrainManager.GRAVE_ROB_CHANCE)
                {
                    Item reward = ItemManager.getTreasure(RandomNumber.RandomDouble());
                    reward.setPosition(x, y);
                    quinoa.getCurrentRegionHeader().getRegion().getItems().Add(reward);
                }

                //open the grave
                terrain.getParameters().Add(TerrainParameter.HAS_GRAVE, EnumUtil.EnumName<GraveCode>(GraveCode.BROKEN));

                //drop bones
                Item bones = new Item();
                bones.itemClass = ItemClass.BONES;
                bones.setPosition(x, y);
                bones.itemState = ItemState.GROUND;
                quinoa.getCurrentRegionHeader().getRegion().getItems().Add(bones);

                return;
            }

            switch(terrain.getCode())
            {
                case TerrainCode.GRASS:
                terrain.setCode(TerrainCode.DIRT);
                break;

                case TerrainCode.DIRT:
                terrain.setCode(TerrainCode.STONE_FLOOR);
                break;

                case TerrainCode.STREAM_BED:
                if(!TerrainManager.hasParameter(terrain, TerrainParameter.HAS_DRAIN))
                {
                    if(!TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SPRING))
                    {
                        terrain.getParameters().Add(TerrainParameter.HAS_SPRING, TerrainManager.SPRING_RATE+"");
                    }
                    else
                    {
                        terrain.getParameters().Remove(TerrainParameter.HAS_SPRING);
                    }
                }
                break;

                default:
                //Do nothing, can not dig
                break;

            }
        }
        //Grow crops on this tile
        public static void growCrops(Terrain terrain, int x, int y, Quinoa quinoa)
        {
            if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SEED))
            {
                if(quinoa.getLightMap().getCalc(x, y) >= TerrainManager.PLANT_LIGHT_LEVEL_MIN)
                {
                    SeedType seedType = (SeedType)Enum.Parse(typeof(SeedType), TerrainManager.getParameter(terrain, TerrainParameter.HAS_SEED));
                    switch(seedType)
                    {
                        case SeedType.CORN:
                        terrain.getParameters().Remove(TerrainParameter.HAS_SEED);
                        terrain.getParameters().Add(TerrainParameter.GROW_COUNTER, TerrainManager.GRASS_GROW_COUNT+"");

                        if(quinoa.getCurrentRegionHeader().getRegion().getItem(x, y) == null)
                        {
                            if(RandomNumber.RandomDouble() < 0.50)
                            {
                                Item cornSeed = new Item();
                                cornSeed.itemClass = ItemClass.CORN_SEED;
                                cornSeed.stackSize = RandomNumber.RandomInteger(9) + 1;
                                cornSeed.setPosition(x, y);
                                quinoa.getCurrentRegionHeader().getRegion().getItems().Add(cornSeed);
                            }

                            Item corn = new Item();
                            corn.itemClass = ItemClass.CORN;
                            corn.stackSize = RandomNumber.RandomInteger(3) + 1;
                            corn.setPosition(x, y);
                            quinoa.getCurrentRegionHeader().getRegion().getItems().Add(corn);
                        }
                        break;

                        case SeedType.PUMPKIN:
                        //reset the counter
                        terrain.getParameters().Add(TerrainParameter.GROW_COUNTER, (TerrainManager.PUMPKIN_GROW_COUNT / 2)+"");

                        //chance to produce a pumpkin
                        if(quinoa.getCurrentRegionHeader().getRegion().getItem(x, y) == null)
                        {
                            if(RandomNumber.RandomDouble() < TerrainManager.PUMPKIN_PRODUCTION_RATE)
                            {
                                Item pumpkinSeed = new Item();
                                pumpkinSeed.itemClass = ItemClass.PUMPKIN_SEED;
                                pumpkinSeed.stackSize = RandomNumber.RandomInteger(3) + 1;
                                pumpkinSeed.setPosition(x, y);
                                quinoa.getCurrentRegionHeader().getRegion().getItems().Add(pumpkinSeed);

                                Item pumpkin = new Item();
                                pumpkin.itemClass = ItemClass.PUMPKIN;
                                pumpkin.stackSize = 1;
                                pumpkin.setPosition(x, y);
                                quinoa.getCurrentRegionHeader().getRegion().getItems().Add(pumpkin);
                            }
                        }
                        break;
                    }
                }
            }
            else
            {
                //no seeds, just grow grass
                terrain.getParameters().Remove(TerrainParameter.GROW_COUNTER);
                terrain.setCode(TerrainCode.GRASS);

                if (RandomNumber.RandomDouble() < TerrainManager.TREE_REGROWTH_RATE)
                {
                    terrain.getParameters().Add(TerrainParameter.HAS_TREE, EnumUtil.EnumName<TreeCode>(TerrainManager.getRandomTree()));
                }
            }
        }
        public static void burn(Terrain terrain, int x, int y, Quinoa quinoa)
        {
            bool dropAsh = false;

            //Look for items on this squares and remove them
            foreach(Item tempItem in quinoa.getCurrentRegionHeader().getRegion().getItems())
            {
                if(tempItem.x == x && tempItem.y == y)
                {
                    switch(tempItem.itemClass)
                    {
                        case ItemClass.LOG: dropAsh=true; break;
                        default: dropAsh= false; break;
                    }
                    tempItem.RemoveObject();
                }
            }

            //Examine terrain features
            if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_TREE))
            {
                terrain.getParameters().Remove(TerrainParameter.HAS_TREE);
                if(RandomNumber.RandomDouble() < 0.125)
                {
                    dropAsh = true;
                }
            }

            if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_DOOR))
            {
                terrain.getParameters().Remove(TerrainParameter.HAS_DOOR);
            }

            if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SIGN))
            {
                terrain.getParameters().Remove(TerrainParameter.HAS_SIGN);
            }

            if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_MUSHROOM_SPORES))
            {
                terrain.getParameters().Remove(TerrainParameter.HAS_MUSHROOM_SPORES);
            }

            if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_CLOVER))
            {
                terrain.getParameters().Remove(TerrainParameter.HAS_CLOVER);
            }

            switch(terrain.getCode())
            {
                case TerrainCode.GRASS:
                if(RandomNumber.RandomDouble() < 0.98)
                {
                    terrain.setCode(TerrainCode.FERTILE_LAND);
                    terrain.getParameters().Add(TerrainParameter.GROW_COUNTER, TerrainManager.GRASS_GROW_COUNT+"");

                    if(RandomNumber.RandomDouble() < 0.001)
                    {
                        int cloverCount = (int)(RandomNumber.RandomDouble() * (TerrainManager.CLOVER_GROW_COUNT / 4)) + TerrainManager.CLOVER_GROW_COUNT;
                        terrain.getParameters().Add(TerrainParameter.HAS_CLOVER, cloverCount+"");
                    }
                    else
                    {
                        if(RandomNumber.RandomDouble() < 0.001)
                        {
                            MushroomSporeCode msc = EnumUtil.RandomEnumValue<MushroomSporeCode>();
                            terrain.getParameters().Add(TerrainParameter.HAS_MUSHROOM_SPORES, EnumUtil.EnumName<MushroomSporeCode>(msc));
                        }
                    }

                }
                else
                {
                    terrain.setCode(TerrainCode.DIRT);
                }
                break;

                default:
                //Do nothing, does not burn
                break;

            }

            if(dropAsh)
            {
                Item ash = new Item();
                ash.itemClass = ItemClass.ASH;
                ash.setPosition(x, y);
                quinoa.getCurrentRegionHeader().getRegion().getItems().Add(ash);
            }
        }