void Start()
    {
        player = gameObject.transform.parent.GetComponentInChildren<Player>();

        //let's create the player
        items = new Items();
        characters = new Characters();
        if (items.LoadItems() && characters.LoadCharacters())
        {
            prefab = Resources.Load(characters.GetCharacter("Guy").GetDirectory(), typeof(GameObject));
            PlayerObject = Instantiate(prefab) as GameObject;
            PlayerObject.transform.position = new Vector3(0, 0.5f, 0);
            PlayerObject.transform.SetParent(gameObject.transform.parent.FindChild("PlayerObject").transform);

            for (int i = -4; i <= 4; i++) //initial 8 tiles
            {
                int rand = Random.Range(0, 2);
                item = items.GetItem(TilesArray[rand]);
                prefab = Resources.Load(item.GetDirectory(), typeof(GameObject));
                ObjectI = Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;
                ObjectI.transform.position = new Vector3(i * 9, 0, 0) + item.GetBasePosition();
                ObjectI.transform.SetParent(gameObject.transform.FindChild("Tiles").transform);
                tiles.Add(ObjectI);
            }
        }
    }

        public static string getZipWithLocalO2Scripts()
        {
            var tempDir = "_TempScriptsFolder".tempDir();
            var localScriptsFolder = PublicDI.config.LocalScriptsFolder;
            var tempScriptsFolder = tempDir.pathCombine("O2.Platform.Scripts");
            var zipFile = tempDir.pathCombine("O2.Platform.Scripts.zip");

            "[getZipWithLocalO2Scripts] Step 1: Copying files".debug();
            Files.copyFolder(localScriptsFolder, tempDir, true, false, ".git");

            "[getZipWithLocalO2Scripts] Step 2: calculating Hashes".debug();
            var files = tempScriptsFolder.files(true);
            var items = new Items();
            foreach (var file in files)
            {
                var hash = file.fileContents_AsByteArray().hash();
                items.add(file.remove(tempScriptsFolder + "\\"), hash.str());
            }
            var hashesFile = tempScriptsFolder.pathCombine("ScriptHashes-{0}.xml".format(DateTime.Now.safeFileName()));
            items.saveAs(hashesFile);

            "[getZipWithLocalO2Scripts] Step 3: Creating Zip".debug();
            tempScriptsFolder.zip_Folder(zipFile);

            return zipFile;
        }

    // Called when an object is interacted with.
    public override Items.Item Interact(Items.Item item = null)
    {
        Items.Item toReturn = null;

        if (tags.Contains("CARROT"))
        {
            World.textbox.Write("You got some carrots.");
            toReturn = Items.getItemWithName("carrot");
            TurnInto(afterInteraction[Random.Range(0, afterInteraction.Length)]);
            World.AddChaos(World.STEAL);
        }
        else if (tags.Contains("CORN"))
        {
            World.textbox.Write("You got some corn.");
            toReturn = Items.getItemWithName("corn");
            TurnInto(afterInteraction[Random.Range(0, afterInteraction.Length)]);
            World.AddChaos(World.STEAL);
        }
        else if (tags.Contains("LETTUCE"))
        {
            World.textbox.Write("You got some lettuce.");
            toReturn = Items.getItemWithName("lettuce");
            TurnInto(afterInteraction[Random.Range(0, afterInteraction.Length)]);
            World.AddChaos(World.STEAL);
        }
        else if (tags.Contains("TOMATO"))
        {
            World.textbox.Write("You got some tomato.");
            toReturn = Items.getItemWithName("tomato");
            TurnInto(afterInteraction[Random.Range(0, afterInteraction.Length)]);
            World.AddChaos(World.STEAL);
        }

        return toReturn;
    }

        /// <summary>
        /// Sets the items to be used in the comparison.
        /// </summary>
        /// <param name="properties"></param>
        /// <param name="item1"></param>
        /// <param name="item2"></param>
        public void SetItems(
            Items.ItemProperty[] properties,
            Items.Item item1,
            Items.Item item2)
        {
            // clear out any prior contents
            RowHost.Children.Clear();
            RowHost.RowDefinitions.Clear();

            // set up our row/column definitions
            for (int index = 0; index < properties.Length; ++index)
            {
                RowHost.RowDefinitions.Add(new RowDefinition());
            }

            // add our columns
            for (int index = 0; index < properties.Length; ++index)
            {
                ComparisonRow row = new ComparisonRow();
                Grid.SetRow(row, index);
                RowHost.Children.Add(row);                
                row.HeadingLabel.Text = properties[index].Name;
                row.Cell1.SetValue(item1.Values[index], properties[index].PropertyType);
                row.Cell2.SetValue(item2.Values[index], properties[index].PropertyType);
            }

            ItemBrand1.Text = item1.Brand;
            ItemBrand2.Text = item2.Brand;
            ItemName1.Text = item1.Name;
            ItemName2.Text = item2.Name;
        }

 // Use this for initialization
 void Start()
 {
     activeboublecolor = bouble.color;
     item = Items.EMPTY;
     bouble.color = Color.clear;
     coloritem = Color.white;
 }

        public void EquipWeapon(Items thing)
        {
            if(thing is Weapon)
            {
                if(weaponCapacity>0)
                {
                    this.Equiped.Add(thing);

                    if (thing is Saber)
                    {
                        var temp = (Saber)thing;

                        attacks.Add(new LightAttackAbility(temp,this));
                    }
                    else if(thing is DarkStaff)
                    {
                        var temp = (DarkStaff)thing;
                        attacks.Add(new LightMagicAbility(temp,this));
                    }
                    weaponCapacity--;
                    this.Inventory.Remove(thing);
                }

                //else { Console.WriteLine("Not Allowed"); }
            }
        }

        public void UneqipWeapon(Items thing)
        {
            if (thing is Weapon)
            {
                Equiped.Remove(thing);
                Inventory.Add(thing);

                if (thing is Saber)
                {
                    var temp = (Saber)thing;
                    LightAttackAbility tempAbility = new LightAttackAbility(temp,this);
                    var tempR=attacks.Find(o=>o.Name==thing.Name+" Light Attack");
                    attacks.Remove(tempR);
                }
                else
                {
                    var temp=(DarkStaff)thing;
                    LightMagicAbility tempAbility = new LightMagicAbility(temp,this);
                    var tempR = attacks.Find(o => o.Name == thing.Name + " Light Magic Attack");
                    attacks.Remove(tempR);
                }

                weaponCapacity++;
            }
        }

 /// <summary>
 /// Adds item to the inventory, keeps already existing items
 /// </summary>
 /// <param name="items">Items.</param>
 public void AddToInventory(Items items, Texture texture)
 {
     float __x = _xPos - inventoryItem.Count * _xOffset;
     Rect __rect = new Rect(__x, _outYPos,_sizeButton,_sizeButton);
     inventoryItem.Add( new InventoryItem(items, texture,__rect));
     StartCoroutine(_MoveItemDown(inventoryItem[inventoryItem.Count-1]));
 }

        public bool EquipItem(Items.Iitem item, Inventory inventory)
        {
            bool result = false;

            Items.Iweapon weaponItem = item as Items.Iweapon;
            if (weaponItem != null && weaponItem.IsWieldable) {
                //can't equip a wieldable weapon
            }
            else {
                if (!equipped.ContainsKey(item.WornOn)) {
                    equipped.Add(item.WornOn, item);
                    if (inventory.inventory.Any(i => i.Id == item.Id)) {//in case we are adding it from a load and not moving it from the inventory
                        inventory.inventory.RemoveWhere(i => i.Id == item.Id); //we moved the item over to equipped so we need it out of inventory
                    }
                    result = true;
                }
                else if (item.WornOn == Items.Wearable.WIELD_LEFT || item.WornOn == Items.Wearable.WIELD_RIGHT) { //this item can go in the free hand
                    Items.Wearable freeHand = Items.Wearable.WIELD_LEFT; //we default to right hand for weapons
                    if (equipped.ContainsKey(freeHand)) freeHand = Items.Wearable.WIELD_RIGHT; //maybe this perosn is left handed
                    if (!equipped.ContainsKey(freeHand)) { //ok let's equip this
                        item.WornOn = freeHand;
                        item.Save();
                        equipped.Add(freeHand, item);
                        if (inventory.inventory.Any(i => i.Id == item.Id)) {//in case we are adding it from a load and not moving it from the inventory
                            inventory.inventory.RemoveWhere(i => i.Id == item.Id); //we moved the item over to equipped so we need it out of inventory
                        }
                        result = true;
                    }
                }
            }

            return result;
        }

    /// <summary>
    /// Initialize interface with default data. 
    /// </summary>
    /// <param name="result"></param>
    public void InitializeData( Items.BaseItem result )
    {
      var res = result as Items.TestResult;

      if( null == res )
      {
        throw new ArgumentException( "Invalid argument type." );
      }

      var isExecuted = res.IsExecuted;

      lblAsserts.Visible = isExecuted;
      lblTime.Visible = isExecuted;
      lblAssertsCap.Visible = isExecuted;
      lblTimeCap.Visible = isExecuted;
      lblErrors.Text = res.Errors ?? "";
      lblFailures.Text = res.Failures ?? "";
      if( isExecuted )
      {
        lblAsserts.Text = res.Asserts.Value.ToString();
        lblTime.Text = res.Time;
      }

      lblExecuted.Text = res.IsExecuted.ToString();
      lblName.Text = res.Name;
      lblresult.Text = res.TestResultValue.ToString();
      lblresult.ForeColor = ( res.TestResultValue == Items.TestResultsEnum.Error ||
        res.TestResultValue == Items.TestResultsEnum.Failure ||
        res.TestResultValue == Items.TestResultsEnum.Invalid ) ? Color.Red : Color.Black;
    }

        /// <summary>
        /// Sets the item and properties to display.
        /// </summary>
        /// <param name="properties">An array of properties to display.</param>
        /// <param name="item">The item to display.</param>
        public void SetItem(
            Items.ItemProperty[] properties,
            Items.Item item)
        {
            // clear out any prior contents
            RowHost.Children.Clear();
            RowHost.RowDefinitions.Clear();

            // set up our row definitions
            for (int index = 0; index < properties.Length; ++index)
            {
                RowHost.RowDefinitions.Add(new RowDefinition());
            }

            // add our rows
            for (int index = 0; index < properties.Length; ++index)
            {
                InformationPanelRow row = new InformationPanelRow();
                Grid.SetRow(row, index);
                RowHost.Children.Add(row);              
                row.HeadingLabel.Text = properties[index].Name;                
                row.Cell.SetValue(item.Values[index], properties[index].PropertyType);
            }

            ItemBrandPanel.Text = item.Brand;
            ItemNamePanel.Text = item.Name;
        }

 public void addToInventory(Items.seeds seed,int amount)
 {
     Items.seeds s = null;
     bool found = false;
     if (seeds.Count == 0)
     {
         seeds.Add(seedcnt, list.cloneSeed(seed));
         seeds[seedcnt].addAmount(amount);
         seedcnt++;
     }
     else
     {
         foreach (KeyValuePair<int, Items.seeds> entry in seeds)
         {
             if (entry.Value.getID() == seed.getID() && found == false)
             {
                 s = entry.Value;
                 found = true;
             }
         }
         if (found)
         {
             s.addAmount(amount);
         }
         else
         {
             seeds.Add(seedcnt, list.cloneSeed(seed));
             seeds[seedcnt].addAmount(amount);
             seedcnt++;
         }
     }
 }

 /// <summary>
 /// Létrehoz egy feladatot a megadott típussal és célponttal
 /// </summary>
 /// <param name="Type">A feladat típusa</param>
 /// <param name="Item">A feladat célpontja</param>
 public Task(TaskType Type, Items.ItemBase Item)
 {
     if (Type == TaskType.Any) { throw new ArgumentException("TaskType.Any cannot be used here"); }
     this.Type = Type;
     this.Item = Item;
     this.AssignedSince = Statistics.CurrentLoop;
 }

        public SecretBrick(int x, int y, Items.Item item)
        {
            this.Breakable = true;
            this.Solid = true;
            this.Position = new Rectangle(x * 24, y * 24, 24, 24);
            this.ImageCount = 0f;
            this.ImageIndex = 0;
            this.ImageSpeed = 1f;
            this.ImageTime = 10f;
            this.HeldItem = item;
            this.OffsetX = 0;
            this.OffsetY = 0;
            if(HeldItem is Items.ItemCoin)
                this.BreakSound = Game1.otherSounds[2];
            else
                this.BreakSound = Game1.otherSounds[3];
            this.HitSound = Game1.otherSounds[1];

            this.SrcRect = new Rectangle[10];
            for (int i = 0; i < this.SrcRect.Length; i++)
            {
                if (i < 7)
                    this.SrcRect[i] = new Rectangle(136, 0, 16, 16);
                else
                    this.SrcRect[i] = new Rectangle(136 + (i - 6) * 17, 0, 16, 16);
            }
        }

 public override bool CanHarvest(Items.ToolItem tool)
 {
     return tool is PickaxeItem &&
         (tool.ToolMaterial == ToolMaterial.Iron ||
         tool.ToolMaterial == ToolMaterial.Gold ||
         tool.ToolMaterial == ToolMaterial.Diamond);
 }

        internal Item GetExtendedItem(Items itemEnum)
        {
            Item item = GetItem(itemEnum);

            HtmlNode root = HtmlDocumentController.GetDotabuffItemRoot(item.Reference);

            if (item.WinRate == null || item.Popularity == null)
            {
                item.WinRate = mainController.ConvertStringToWinRate(root.SelectSingleNode(ItemPath.General.WinRate.Value).InnerText);
                item.Popularity = mainController.ConvertStringToPopularity(root.SelectSingleNode(ItemPath.General.Popularity.Value).InnerText);

                string url = UrlPath.Main + root.SelectSingleNode(ItemPath.General.Image.Value).Attributes[MainController.HTML_ATTRIBUTE_SRC].Value;
                using (WebClient webclient = HtmlDocumentController.CreateWebclient())
                {
                    item.Image = webclient.DownloadData(url);
                }
            }

            if (item.ItemDetails == null)
                item.ItemDetails = itemDetailsController.FetchItemDetails(item.Reference);

            item.BuildsInto = FetchBuildsList(root, ItemPath.Details.BuildsInto.Value);

            item.BuildsFrom = FetchBuildsList(root, ItemPath.Details.BuildsFrom.Value);

            return item;
        }

    public static ArrayList GetInventoryByType(string inventoryType)
    {
        ArrayList list = new ArrayList();
        string query = string.Format("SELECT * FROM items", inventoryType);

        try
        {
            conn.Open();
            command.CommandText = query;
            SqlDataReader reader = command.ExecuteReader();

            while (reader.Read())
            {
                int itemid = reader.GetInt32(0);
                string name = reader.GetString(1);
                string categoryname = reader.GetString(2);
                string description = reader.GetString(3);
        //        string imagepath = reader.GetString(4);
         //       bool available = reader.GetBoolean(4);
         //       bool staffonly = reader.GetBoolean(5);

                Items Items = new Items(itemid, name, categoryname, description/* imagepath, available, staffonly*/);
                list.Add(Items);
            }
        }
        finally
        {
            conn.Close();
        }

        return list;
    }

 public static Items property_Values_AsStrings(this object _object)
 {
     var propertyValues_AsStrings = new Items();
     foreach(var property in _object.type().properties())
         propertyValues_AsStrings.add(property.Name.str(), _object.property(property.Name).str());
     return propertyValues_AsStrings;
 }

        public Door(Vector3 position, bool isWestEast, bool isOpen, Items.Door door) : base(position)
        {
            doorFrame = new ModelGraphic();
            doorFrame.Model = doorFrame.Resources.Content.Load<Model>("Models/outterDoor");
            doorFrame.Rotation = isWestEast ? new Vector3(0, MathHelper.PiOver2, 0) : Vector3.Zero;
            doorFrame.Position = position + (isWestEast ? new Vector3(0.4f, 0, 0) : new Vector3(0, 0, 0.4f));
            doorFrame.Scale = new Vector3(1, 0.98f, 0.2f);

            this.door = door;
            door.Graphic.Rotation = isWestEast ? new Vector3(0, MathHelper.PiOver2, 0) : Vector3.Zero;
            door.Position = position + new Vector3((1 - door.Size.X) / 2f, 0, (1 - door.Size.Z) / 2f);
            SubItems.Add(door);

            graphics = new GraphicsCollection(wallGraphic, doorFrame);
            graphics.SubDrawable.Add(door);
            graphicsProviders.SubProviders.Add(graphics);

            ContentActivated = isOpen;

            if (door.HasButton)
            {
                Vector3 shift = !isWestEast ? new Vector3(0, 0, 0.4f) : new Vector3(0.4f, 0, 0);
                var t = new SwitchActuator(position + new Vector3(0, 0.2f, 0) + shift, this, new ActionStateX(ActionState.Toggle, 0, isOnceOnly: false));
                SubItems.Add(t);
            }
        }

        private void appBarOkButton_Click(object sender, EventArgs e)
        {
            CategoryBean tb = (CategoryBean)selectedCategory.SelectedItem;
            if (String.IsNullOrEmpty(tb.CategoryName))
            {
                MessageBox.Show("Error: Category is not selected.");
                return;
            }
            Items newItem = new Items
            {
                CategoryID = tb.ID,
                StartTime = DateTime.Now,
                EndTime = DateTime.Now,
                IsActivity = true,
                UpdateTime = DateTime.Now

            };
            App.ViewModel.AddItem(newItem, tb);

            // Return to the main page.
            if (NavigationService.CanGoBack)
            {
                NavigationService.GoBack();
            }
        }