コード例 #1
0
    public void CombineRecipeShouldAddNewCommonItemFromRecipe()
    {
        // Arrange
        var item1 = new CommonItem("CommonItem1", 1, 2, 3, 4, 5);
        var item2 = new CommonItem("CommonItem2", 6, 7, 8, 9, 10);

        this.heroInventory.AddCommonItem(item1);
        this.heroInventory.AddCommonItem(item2);

        var requiredItems = new List <string>()
        {
            "CommonItem1", "CommonItem2"
        };
        var recipe = new RecipeItem("CommonItem3", 100, 200, 300, 400, 500, requiredItems);

        // Act
        MethodInfo method = GetMethodByName("CombineRecipe");

        method.Invoke(this.heroInventory, new object[] { recipe });

        var commonItemsCollection = GetCommonItems();

        // Assert
        Assert.AreEqual(true, commonItemsCollection.ContainsKey(recipe.Name),
                        "New common item was not added!");
    }
コード例 #2
0
        private static RecipeItem CreateIngredientWorkbenchItem(RecipeCounter counter, RecipeItem parent, ItemModel item, int depth)
        {
            var ingredient = new RecipeItem(counter)
            {
                Id    = -1,
                Depth = depth,
                Item  = new Item
                {
                    Id       = item.Item.Id,
                    RecipeId = item.Item.RecipeId,

                    Name         = item.Item.Name,
                    SellPrice    = item.Item.SellPrice,
                    BuyPrice     = item.Item.BuyPrice,
                    SellOffers   = item.Item.SellOffers,
                    BuyOrders    = item.Item.BuyOrders,
                    RarityId     = item.Item.RarityId,
                    RarityName   = item.Item.RarityName,
                    CategoryId   = item.Item.CategoryId,
                    CategoryName = item.Item.CategoryName,
                    TypeId       = item.Item.TypeId,
                    TypeName     = item.Item.TypeName
                }
            };

            ingredient.Number = 1;
            ingredient.Parent = parent;
            return(ingredient);
        }
コード例 #3
0
    public void AddRecipeItemWithUniqueItemsShouldAddAllItems()
    {
        // Arrange
        var requiredItems = new List <string>()
        {
            "i1", "i2"
        };
        var item1 = new RecipeItem("Common Item 1", 1, 2, 3, 4, 5, requiredItems);
        var item2 = new RecipeItem("Common Item 2", 6, 7, 8, 9, 10, requiredItems);
        var item3 = new RecipeItem("Common Item 3", 11, 12, 13, 14, 15, requiredItems);

        var inputCollection = new List <IRecipe>()
        {
            item1, item2, item3
        };

        // Act
        this.heroInventory.AddRecipeItem(item1);
        this.heroInventory.AddRecipeItem(item2);
        this.heroInventory.AddRecipeItem(item3);

        IDictionary <string, IRecipe> collection = GetRecipeItems();

        // Assert
        CollectionAssert.AreEqual(inputCollection, collection.Values.ToList(),
                                  "Returned collection did not match input collection!");
    }
コード例 #4
0
    public void CombineRecipeShouldUpdateCommonItemsCount()
    {
        // Arrange
        var item1 = new CommonItem("CommonItem1", 1, 2, 3, 4, 5);
        var item2 = new CommonItem("CommonItem2", 6, 7, 8, 9, 10);

        this.heroInventory.AddCommonItem(item1);
        this.heroInventory.AddCommonItem(item2);

        var requiredItems = new List <string>()
        {
            "CommonItem1", "CommonItem2"
        };
        var recipe = new RecipeItem("CommonItem3", 100, 200, 300, 400, 500, requiredItems);

        // Act

        /* Method should remove existing common items (CommonItem1, CommonItem2)
         * and add a new common item with params from recipe (CommonItem3)
         * Common Items count should be 1 (the newly added item)
         */
        MethodInfo method = GetMethodByName("CombineRecipe");

        method.Invoke(this.heroInventory, new object[] { recipe });
        var commonItemsCollection = GetCommonItems();

        // Assert
        Assert.AreEqual(1, commonItemsCollection.Count,
                        "Common items count is incorrect!");
    }
コード例 #5
0
        public void RecipeItem_ToDomainModel_ShouldMapNonNullItem()
        {
            DB.RecipeItem dbItem = new DB.RecipeItem
            {
                Id   = 1,
                Item = new DB.Item {
                    Id = 1, Name = "Onion"
                },
                RequiredQuantity = new Quantity {
                    Amount = 100, Unit = "g"
                },
                Adjectives = new List <string> {
                    "cooked", "chopped"
                }
            };

            RecipeItem item = EntityMapper.ToDomainModel(dbItem);

            dbItem.Should().NotBeNull();
            dbItem.Id.Should().Be(1);
            dbItem.Item.Should().NotBeNull();
            dbItem.RequiredQuantity.Should().NotBeNull();
            dbItem.RequiredQuantity.Amount.Should().Be(100);
            dbItem.RequiredQuantity.Unit.Should().Be("g");
            dbItem.Adjectives.Should().NotBeNullOrEmpty();
            dbItem.Adjectives.Should().HaveCount(2);
            dbItem.Adjectives.Should().Contain(new List <string> {
                "cooked", "chopped"
            });
        }
コード例 #6
0
    public string AddRecipeToHero(IList <string> arguments)
    {
        string result = null;

        string itemName          = arguments[0];
        string heroName          = arguments[1];
        int    strengthBonus     = int.Parse(arguments[2]);
        int    agilityBonus      = int.Parse(arguments[3]);
        int    intelligenceBonus = int.Parse(arguments[4]);
        int    hitPointsBonus    = int.Parse(arguments[5]);
        int    damageBonus       = int.Parse(arguments[6]);

        string[] requiredItems = arguments.Skip(7).ToArray();

        RecipeItem newRecipe = new RecipeItem(
            itemName,
            strengthBonus,
            agilityBonus,
            intelligenceBonus,
            hitPointsBonus,
            damageBonus,
            requiredItems);

        this.Heroes[heroName].Inventory.AddRecipeItem(newRecipe);

        result = string.Format(Constants.RecipeCreatedMessage, newRecipe.Name, heroName);
        return(result);
    }
コード例 #7
0
        public void RecipeItem_ToDatabaseModel_ShouldMapNullItem()
        {
            RecipeItem item = null;

            DB.RecipeItem dbItem = EntityMapper.ToDatabaseModel(item);
            dbItem.Should().BeNull();
        }
コード例 #8
0
        public void RecipeItem_ToDomainModel_ShouldMapNullItem()
        {
            DB.RecipeItem dbItem = null;
            RecipeItem    item   = EntityMapper.ToDomainModel(dbItem);

            item.Should().BeNull();
        }
コード例 #9
0
ファイル: RecipeServiceREST.cs プロジェクト: GodEats/SEP3
        public Recipe DataToBusiness(DataRecipe dataRecipe)
        {
            Recipe returned = new Recipe();

            returned.Ingredient    = new List <RecipeItem>();
            returned.Name          = dataRecipe.Name;
            returned.Id            = dataRecipe.Id;
            returned.MinutesToMake = dataRecipe.MinutesToMake;
            returned.Description   = dataRecipe.Description;
            returned.Calories      = dataRecipe.Calories;
            returned.NutritionType = dataRecipe.NutritionType;
            returned.Image         = dataRecipe.Image;
            returned.Price         = dataRecipe.Price;

            List <string> ids      = dataRecipe.IngredientIdList.Split(",").ToList();
            List <string> quantity = dataRecipe.IngredientQuantityList.Split(",").ToList();

            for (int i = 0; i < ids.Count - 1; i++)
            {
                RecipeItem temp = new RecipeItem();
                temp.IngredientId = Convert.ToInt32(ids[i]);
                temp.Amount       = Convert.ToInt32(quantity[i]);
                returned.Ingredient.Add(temp);
            }

            return(returned);
        }
コード例 #10
0
        private string GetIcon(RecipeItem item, bool inputIngots)
        {
            String name  = Utils.OreGot(item.name, !inputIngots);
            bool   range = item.start != 0 || item.stop != 0;
            string value;

            if (item.value == 0)
            {
                value = String.Format("{0}-{1}", Utils.FormatNumber(item.start), Utils.FormatNumber(item.stop));
            }
            else
            {
                value = Utils.FormatNumber(item.value);
            }
            var imgName = name;

            if (name == "Carbon" || name == "Hydrocarbon")
            {
                imgName = "ItemCoalOre";
            }

            String className = range ? "stationeers-icon icon-range" : "stationeers-icon";

            return(String.Format("<div class=\"{0}\">[[File:{1}.png|link={2}]] <div class=\"stationeers-icon-text\">{3}</div></div>",
                                 className, imgName, GetTranslatedName(name), value));
        }
コード例 #11
0
        public override string Execute()
        {
            try
            {
                string heroName = args[1];
                IHero  hero     = this.manager.heroes[heroName];
                string itemName = args[0];

                int           strengthBonus     = int.Parse(args[2]);
                int           agilityBonus      = int.Parse(args[3]);
                int           intelligenceBonus = int.Parse(args[4]);
                int           hitPointsBonus    = int.Parse(args[5]);
                int           damageBonus       = int.Parse(args[6]);
                List <string> neededList        = args.Skip(7).ToList();
                IRecipe       recipeItem        = new RecipeItem(itemName, strengthBonus, agilityBonus, intelligenceBonus,
                                                                 hitPointsBonus, damageBonus, neededList);
                hero.AddRecipe(recipeItem);

                return(string.Format(Constants.RecipeCreatedMessage, itemName, heroName));
            }
            catch (Exception e)
            {
                return(e.Message);
            }
        }
コード例 #12
0
        public string AddRecipe(IList <string> arguments)
        {
            string itemName          = arguments[0];
            string heroName          = arguments[1];
            int    strengthBonus     = int.Parse(arguments[2]);
            int    agilityBonus      = int.Parse(arguments[3]);
            int    intelligenceBonus = int.Parse(arguments[4]);
            int    hitPointsBonus    = int.Parse(arguments[5]);
            int    damageBonus       = int.Parse(arguments[6]);
            var    requiredItems     = arguments.Skip(7).ToList().Where(i => i != "").ToList();

            var newItem = new RecipeItem(
                itemName,
                strengthBonus,
                agilityBonus,
                intelligenceBonus,
                hitPointsBonus,
                damageBonus,
                requiredItems);

            this.heroes[heroName].AddRecipe(newItem);

            string result = string.Format(Constants.RecipeCreateMessage, itemName, heroName);

            return(result);
        }
コード例 #13
0
        public IActionResult DeleteData(RecipeFormViewModelData recipe)
        {
            RecipeItem newRecipe = new RecipeItem();

            newRecipe.RecipeName  = recipe.RecipeName;
            newRecipe.ServingSize = recipe.ServingSize;
            newRecipe.Description = recipe.Description;
            newRecipe.RecipeId    = recipe.RecipeId;
            Ingredient newIngredient = new Ingredient();

            newIngredient.IngredientName = recipe.Ingredient;
            newIngredient.IngredientId   = recipe.RecipeId;
            Equipment newEquipment = new Equipment();

            newEquipment.EquipmentName = recipe.Equipment;
            newEquipment.EquipmentId   = recipe.RecipeId;
            newRecipe.Instructions     = recipe.Instructions;
            Review newReview = new Review();

            newReview.ReviewText = recipe.Review;
            newReview.ReviewId   = recipe.RecipeId;

            repository.DeleteRecipe(newRecipe);
            repository.DeleteReview(newReview);
            repository.DeleteIngredient(newIngredient);
            repository.DeleteEquipment(newEquipment);

            return(RedirectToAction("DataPage", "Home"));
        }
コード例 #14
0
        public void ResolveRecipe(RecipeCounter counter, RecipeItem parent, int depth, bool resolveDeep, bool addWorkbenchItem)
        {
            foreach (var ingredient in parent.Ingredients)
            {
                ingredient.Parent = parent;
                ingredient.Depth  = depth;
                if (ingredient.Item.RecipeId > 0 && resolveDeep)
                {
                    ingredient.Ingredients = SelectRecipe(counter, ingredient.Item);
                    ++depth;
                    ResolveRecipe(counter, ingredient, depth, true, addWorkbenchItem);
                    CalculateRecipe(ingredient);
                    if (ingredient.Depth > 0)
                    {
                        ingredient.IngredientSum = CreateIngredientItem(counter, ingredient);
                    }
                    parent.MaxDepth = Math.Max(depth, ingredient.MaxDepth);
                    depth--;
                }
            }

            if (addWorkbenchItem)
            {
                AddWorkbenchCostItem(counter, parent, depth);
            }
        }
コード例 #15
0
ファイル: RecipeService.cs プロジェクト: ilos67/ExpiApp
        public async Task <Product> CreateOrderAsync(int id, string basketId)
        {
            // get basket from the repo
            var basket = await _basketRepo.GetBasketAsync(basketId);

            // get items from the product repo
            var items = new List <RecipeItem>();

            foreach (var item in basket.Items)
            {
                var productItem = await _unitOfWork.Repository <Ingredient>().GetByIdAsync(item.Id);

                var itemOrdered = new IngredientItemAdded(productItem.Id, productItem.Name);
                var orderItem   = new RecipeItem(itemOrdered, productItem.Price, item.Quantity);
                items.Add(orderItem);
            }

            // create order
            var order = new Product(items);

            _unitOfWork.Repository <Product>().Add(order);

            // save to db
            var result = await _unitOfWork.Complete();

            if (result <= 0)
            {
                return(null);
            }

            // return order
            return(order);
        }
コード例 #16
0
    public string AddRecipeToHero(List <string> arguments)
    {
        string result = null;

        string recipeName        = arguments[0];
        string heroName          = arguments[1];
        long   strengthBonus     = long.Parse(arguments[2]);
        long   agilityBonus      = long.Parse(arguments[3]);
        long   intelligenceBonus = long.Parse(arguments[4]);
        long   hitPointsBonus    = long.Parse(arguments[5]);
        long   damageBonus       = long.Parse(arguments[6]);

        List <string> requiredItems = arguments.Skip(7).ToList();

        IRecipe newRecipe = new RecipeItem(recipeName,
                                           strengthBonus,
                                           agilityBonus,
                                           intelligenceBonus,
                                           hitPointsBonus,
                                           damageBonus,
                                           requiredItems);

        this.heroes[heroName].AddRecipe(newRecipe);

        result = string.Format(Constants.RecipeCreatedMessage, newRecipe.Name, heroName);

        return(result);
    }
コード例 #17
0
    public override void _Ready()
    {
        click = (AudioStreamPlayer)GetTree().GetRoot().GetNode("SceneSwitcher/Click");
        paper = (NinePatchRect)GetNode("ReferenceRect/NinePatchRect");

        holder   = (ReferenceRect)GetNode("ReferenceRect");
        riPrefab = (PackedScene)ResourceLoader.Load("res://Instances/RecipeItem.tscn");

        GetRecipes();
        Vector2 pos = new Vector2(53, 192);

        foreach (Recipe r in recipes)
        {
            RecipeItem recipeItem = (RecipeItem)riPrefab.Instance();
            recipeItem.name        = r.name;
            recipeItem.ingredients = r.ingredients;
            recipeItem.SetPosition(pos);
            GetNode("ReferenceRect").AddChild(recipeItem);
            pos.y += 139;
        }
        Button button = (Button)GetNode("ReferenceRect/Button");

        pos.x  = 29;
        pos.y += 30;
        button.SetPosition(pos);
        NinePatchRect ninePatchRect = (NinePatchRect)GetNode("ReferenceRect/NinePatchRect");

        ninePatchRect.SetSize(new Vector2(ninePatchRect.GetSize().x, pos.y + 102));
    }
コード例 #18
0
        public async Task <ActionResult <RecipeItem> > PostRecipeItem(RecipeItem item)
        {
            _context.RecipeItems.Add(item);
            await _context.SaveChangesAsync();

            return(CreatedAtAction(nameof(GetRecipeItem), new { id = item.Id }, item));
        }
コード例 #19
0
        private static bool RemoveRequiredItemsFromInventory(GameSession session, RecipeMetadata recipe)
        {
            List <Item>       playerInventoryItems = new(session.Player.Inventory.Items.Values);
            List <RecipeItem> ingredients          = recipe.GetIngredients();

            for (int i = 0; i < ingredients.Count; i++)
            {
                RecipeItem ingredient = ingredients.ElementAt(i);
                Item       item       = playerInventoryItems.FirstOrDefault(x => x.Id == ingredient.Id);
                if (item == null)
                {
                    continue;
                }

                // check if whole stack will be used, and remove the item
                // otherwise we want to just want to subtract the amount
                if (ingredient.Amount == item.Amount)
                {
                    InventoryController.Remove(session, item.Uid, out Item _);
                }
                else
                {
                    InventoryController.Update(session, item.Uid, item.Amount - ingredient.Amount);
                }
            }

            return(true);
        }
コード例 #20
0
ファイル: RecipeItemsController.cs プロジェクト: Ananas97/TSD
        public async Task <IActionResult> PutRecipeItem(int id, RecipeItem recipeItem)
        {
            if (id != recipeItem.ID)
            {
                return(BadRequest());
            }

            _context.Entry(recipeItem).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!RecipeItemExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #21
0
        /// <summary>
        /// Retrieve all recipe items owned by a recipe.
        /// </summary>
        /// <param name="owner">The owner of the desired recipe items.</param>
        /// <returns>The owned recipe items.</returns>
        public IList <RecipeItem> GetRecipeItemsByOwner(Recipe owner)
        {
            List <RecipeItem> res = new List <RecipeItem>();

            string cmd = $"SELECT {RI_TABLE_NAME}.{RI_ID_COL}, {RI_TABLE_NAME}.{RI_PERCENTAGE_COL}, " +
                         $"{FLAVOR_TABLE_NAME}.{FLAVOR_ID_COL}, {FLAVOR_TABLE_NAME}.{FLAVOR_NAME_COL}, " +
                         $"{FLAVOR_TABLE_NAME}.{FLAVOR_PG_COL}, {FLAVOR_TABLE_NAME}.{FLAVOR_RECPER_COL} " +
                         $"FROM {RI_TABLE_NAME} JOIN {FLAVOR_TABLE_NAME} " +
                         $"ON {RI_TABLE_NAME}.{RI_FLAVOR_COL}={FLAVOR_TABLE_NAME}.{FLAVOR_ID_COL} " +
                         $"JOIN {RECIPE_RI_TABLE_NAME} " +
                         $"ON {RI_TABLE_NAME}.{RI_ID_COL}={RECIPE_RI_TABLE_NAME}.{RECIPE_RI_RI_ID} " +
                         $"WHERE {RECIPE_RI_RECIPE_ID}={owner.ID};";

            try {
                ICursor iter = ReadableDatabase.RawQuery(cmd, null);
                while (iter.MoveToNext())
                {
                    RecipeItem ri = ParseRecipeItem(iter);
                    if (ri != null)
                    {
                        res.Add(ri);
                    }
                }
                iter.Close();
            } catch (SQLiteAbortException e) {
                Console.WriteLine(e.Message);
            }

            return(res);
        }
コード例 #22
0
        /// <summary>
        /// Execute RemoveRecipeItemCommand
        /// </summary>
        /// <param name="item">Selected item to be processed.</param>
        private void ExecuteRemoveRecipeItemCommand(RecipeItem item)
        {
            try
            {
                if (item == null)
                {
                    throw new ArgumentNullException("item");
                }

                //this.Item.Recipes.Remove(item);
                if (this.Item.Recipes.Contains(item))
                {
                    this.Item.Recipes.Remove(item);

                    List <RecipeItem> list = (List <RecipeItem>)(this.Item.Recipes as IEditableCollection).GetDeletedList();

                    string message = "Deleted List: \n";
                    foreach (RecipeItem recipeItem in list)
                    {
                        message += recipeItem.MaterialInfo.Name + "\n";
                    }
                    this.MessageBoxService.ShowInformation(message);
                }
                else
                {
                    this.MessageBoxService.ShowInformation("This item is not in the list.");
                }
            }
            catch (Exception ex)
            {
                this.MessageBoxService.ShowError(this.GetType().FullName + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message);
            }
        }
コード例 #23
0
    public void Chech_Add_Recipe_To_Inventory_Without_Making_Item()
    {
        HeroInventory heroInventory = new HeroInventory();
        var           item1         = new CommonItem("a", 1, 1, 1, 1, 1);
        var           item2         = new CommonItem("b", 1, 1, 1, 1, 1);


        heroInventory.AddCommonItem(item1);
        heroInventory.AddCommonItem(item2);
        var combine = new RecipeItem("A", 1, 1, 1, 1, 1, new List <string>
        {
            "a",
            "b",
            "c"
        });

        heroInventory.AddRecipeItem(combine);
        Type type = heroInventory.GetType();

        FieldInfo[] fieldInfo            = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
        FieldInfo   commonItemsStorage   = fieldInfo.First(f => f.GetCustomAttributes <ItemAttribute>() != null);
        Dictionary <string, IItem> items = (Dictionary <string, IItem>)commonItemsStorage.GetValue(heroInventory);


        Assert.AreEqual(2, items.Count);

        var item3 = new CommonItem("c", 1, 1, 1, 1, 1);

        heroInventory.AddCommonItem(item3);
        Assert.AreEqual(1, items.Values.Count);
    }
コード例 #24
0
    public void Check_Combine_Method_In_HeroInventory()
    {
        var inventory = new HeroInventory();
        var item1     = new CommonItem("a", 1, 1, 1, 1, 1);
        var item2     = new CommonItem("b", 1, 1, 1, 1, 1);
        var item3     = new CommonItem("c", 1, 1, 1, 1, 1);
        var item4     = new CommonItem("d", 1, 1, 1, 1, 1);
        var combine   = new RecipeItem("A", 1, 1, 1, 1, 1, new List <string>
        {
            "a",
            "b"
        });

        inventory.AddCommonItem(item1);
        inventory.AddCommonItem(item2);
        inventory.AddCommonItem(item3);
        inventory.AddCommonItem(item4);
        inventory.AddRecipeItem(combine);
        Type type = inventory.GetType();

        FieldInfo[] fieldInfo            = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
        FieldInfo   commonItemsStorage   = fieldInfo.First(f => f.GetCustomAttributes <ItemAttribute>() != null);
        Dictionary <string, IItem> items = (Dictionary <string, IItem>)commonItemsStorage.GetValue(inventory);

        Assert.AreEqual(3, items.Values.Count);
    }
コード例 #25
0
        private static RecipeItem CreateIngredientItem(RecipeItem item)
        {
            var ingredientSum = new RecipeItem
            {
                Id    = -1,
                Depth = item.Depth,
                Item  = new Item
                {
                    Id       = item.Item.Id,
                    RecipeId = item.Item.RecipeId,

                    Name         = item.Item.Name,
                    SellPrice    = item.SumSell,
                    BuyPrice     = item.SumBuy,
                    SellOffers   = item.Item.SellOffers,
                    BuyOrders    = item.Item.BuyOrders,
                    RarityId     = item.Item.RarityId,
                    RarityName   = item.Item.RarityName,
                    CategoryId   = item.Item.CategoryId,
                    CategoryName = item.Item.CategoryName,
                    TypeId       = item.Item.TypeId,
                    TypeName     = item.Item.TypeName
                }
            };

            ingredientSum.Parent   = item;
            ingredientSum.IsSumRow = true;
            return(ingredientSum);
        }
コード例 #26
0
        private void HandleAddNewIngredientCommand(object parameter)
        {
            RecipeItem selectedRecipeItem = parameter as RecipeItem;

            selectedRecipeItem.RecipeItems_Ingredients.Add(new RecipeItems_Ingredients());
            this.OnPropertyChanged("Recipe");
        }
コード例 #27
0
        public AddRecipeResponse AddRecipes(AddRecipeRequest request)
        {
            var response = new AddRecipeResponse();
            var recipe   = new Recipe
            {
                Title = request.model.Title
            };

            if (request.model.Ingredients != null && request.model.Ingredients.Count() > 0)
            {
                var items = new List <RecipeItem>();
                foreach (var item in request.model.Ingredients)
                {
                    var newItem = new RecipeItem
                    {
                        IngredientId = item.IngredientId,
                        Measure      = (Measure)item.Measure,
                        Quantity     = item.Quantity
                    };
                    items.Add(newItem);
                }
                recipe.Ingredients = items.AsEnumerable();
            }

            if (!recipe.isValid())
            {
                throw new BusinessRuleException("There was some errors", recipe.getBrokedRules());
            }

            _recipeRepository.Insert(recipe);
            _unitOfWork.Commit();

            response.recipe = recipe.ToRecipeViewModel();
            return(response);
        }
コード例 #28
0
    public void TestAddingNewRecipeItemInInventory()
    {
        //Arrange
        CommonItem item   = new CommonItem("item", 1, 2, 3, 4, 5);
        CommonItem item2  = new CommonItem("item2", 1, 2, 3, 4, 5);
        IRecipe    recipe = new RecipeItem("recipe", 10, 20, 30, 40, 50, new List <string>()
        {
            item.Name, item2.Name
        });

        //Act
        this.inventory.AddCommonItem(item);
        this.inventory.AddCommonItem(item2);
        this.inventory.AddRecipeItem(recipe);

        Type inventoryType = typeof(HeroInventory);

        var fieldItemColl = inventoryType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
                            .FirstOrDefault(f => f.GetCustomAttributes(typeof(ItemAttribute)) != null);
        var collectionItem = (Dictionary <string, IItem>)fieldItemColl.GetValue(this.inventory);

        var fieldRecipeColl
            = inventoryType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).Skip(1)
              .FirstOrDefault();
        var collectionRecipe = (Dictionary <string, IRecipe>)fieldRecipeColl.GetValue(this.inventory);

        //Assert
        Assert.AreEqual(10, this.inventory.TotalStrengthBonus);
        Assert.AreEqual(20, this.inventory.TotalAgilityBonus);
        Assert.AreEqual(30, this.inventory.TotalIntelligenceBonus);
        Assert.AreEqual(40, this.inventory.TotalHitPointsBonus);
        Assert.AreEqual(50, this.inventory.TotalDamageBonus);
        Assert.AreEqual(1, collectionItem.Count);
        Assert.AreEqual(1, collectionRecipe.Count);
    }
コード例 #29
0
        public ViewResult InsertPage(RecipeFormViewModelData recipe)
        {
            if (ModelState.IsValid)
            {
                RecipeItem newRecipe = new RecipeItem();
                newRecipe.RecipeName  = recipe.RecipeName;
                newRecipe.ServingSize = recipe.ServingSize;
                newRecipe.Description = recipe.Description;
                Ingredient newIngredient = new Ingredient();
                newIngredient.IngredientName = recipe.Ingredient;
                Equipment newEquipment = new Equipment();
                newEquipment.EquipmentName = recipe.Equipment;
                newRecipe.Instructions     = recipe.Instructions;

                repository.AddRecipe(newRecipe);
                repository.AddIngredient(newIngredient);
                repository.AddEquipment(newEquipment);
                repository.AddReview(new Review());
                return(View("DataPage", repository.Recipes));
            }
            else
            {
                return(View());
            }
        }
コード例 #30
0
        public async Task <List <Recipe> > GetRecipes()
        {
            List <Recipe>           recipes = new List <Recipe>();
            List <Models.DB.Recipe> fromDB  = await this.foodDatabase.GetRecipes();

            foreach (var recipeFromDB in fromDB)
            {
                Recipe recipe = ConvertFromDb(recipeFromDB);
                recipes.Add(recipe);

                List <Models.DB.RecipeItem> items = await this.foodDatabase.GetRecipeItems(recipeFromDB.Id);

                foreach (var recipeItemDB in items)
                {
                    Models.DB.Food foodDb = await this.foodDatabase.FoodById(recipeItemDB.FoodId);

                    RecipeItem recipeItem = ConvertFromDb(recipeItemDB);
                    recipeItem.Food = FoodRepository.ConvertFromDb(foodDb);

                    recipe.Items.Add(recipeItem);
                }
            }

            return(recipes);
        }
コード例 #31
0
ファイル: RecepiItemInfo.cs プロジェクト: Kinderril/p3
 public void Init(RecipeItem recipeItem,bool WithButtons)
 {
     base.Init(recipeItem,true, WithButtons);
     mainIcon.sprite = recipeItem.IconSprite;
     NameLabel.text = recipeItem.Name;
     RecipeButton.gameObject.SetActive(WithButtons);
     //        SlotLabel.sprite = DataBaseController.Instance.SlotIcon(recipeItem.Slot);
 }
コード例 #32
0
ファイル: PotionBook.cs プロジェクト: hassank/WendyWebVR
    public void OnAddToCauldron(RecipeItem item)
    {
        var matchingIcon = recipeIcons.Find(i => i.itemName == item.itemName);

        if (matchingIcon != null) {
            StartCoroutine(ShowOnRecipeCo(matchingIcon));
        }
    }
コード例 #33
0
        public void InsertRecipe()
        {
            var recipe = new PrivateRecipe();

            var item1= new RecipeItem {Description = "Step 1"};
            var item2= new RecipeItem {Description = "Step 2"};
            recipe.Add(item1);
            recipe.Add(item2);

            privateRecipeRepository.Insert(recipe);
        }
コード例 #34
0
        public void ClearShouldRemoveAllItems()
        {
            var sut = new PrivateRecipe(_author, _title);
            var recipeItem1 = new RecipeItem(_itemDescription, sut);
            var recipeItem2 = new RecipeItem(_itemDescription, sut);
            sut.Add(recipeItem1);
            sut.Add(recipeItem2);

            sut.Clear();

            sut.Items.Count.ShouldEqual(0);
        }
コード例 #35
0
ファイル: CraftWindow.cs プロジェクト: Kinderril/p3
    public void Init(RecipeItem recipeItem,Action<BaseItem> OnCraftComplete )
    {
        this.OnCraftComplete = OnCraftComplete;
        gameObject.SetActive(true);
        if (recipeItem.recipeSlot != Slot.Talisman)
        {
            string icon;
            RenderCam.Instance.DoRender(recipeItem.recipeSlot, out icon);
            Utils.LoadTexture(icon,out iconSprite);
        }
        else
        {
//            iconSprite = DataBaseController.Instance.TalismanIcon()
        }
        selectedCatalysItem = null;
        CraftInfoPlace.Init(recipeItem,null);
        this.recipeItem = recipeItem;
        elements.Clear();
        BaseWindow.ClearTransform(CraftItemsLayout);
        canCraft = true;
        foreach (var craftElement in recipeItem.ItemsToCraft())
        {
            if (craftElement.count > 0)
            {
                CraftItemElement craftItemElement = DataBaseController.GetItem<CraftItemElement>(CraftItemPrefab);
                craftItemElement.transform.SetParent(CraftItemsLayout, false);
                craftItemElement.Init(craftElement);
                if (!craftItemElement.IsEnought)
                {
                    failElement = craftItemElement;
                    canCraft = false;
                }
            }
        }
        var allCatalys = MainController.Instance.PlayerData.GetAllItems().Where(x => x is ExecCatalysItem);
        BaseWindow.ClearTransform(CatalysItemsLayout);
        foreach (var cat in allCatalys)
        {
            CatalysItemElement catalysItemElement = DataBaseController.GetItem<CatalysItemElement>(CatalysItemPrefab);
            catalysItemElement.Init(cat as ExecCatalysItem, OnCatalysClick);
            catalysItemElement.transform.SetParent(CatalysItemsLayout,false);
            catalysElements.Add(catalysItemElement);
        }
        CatalysItemElement catalysItemElementFree = DataBaseController.GetItem<CatalysItemElement>(CatalysItemPrefab);
        catalysItemElementFree.Init(null, OnCatalysClick);
        catalysItemElementFree.transform.SetParent(CatalysItemsLayout, false);
        catalysElements.Add(catalysItemElementFree);

        CraftResultPlace.Init(iconSprite, null);
    }
コード例 #36
0
ファイル: Craft.cs プロジェクト: anondev/XIACE
 public unsafe void WriteOrder(RecipeItem[] item, int startIndex)
 {
     if (item == null || ((item.Length - startIndex) < 8))
         return;
     for (int i = 0; i < 8; i++) {
         id[i] = (ushort) item[startIndex + i].id;
         count[i] = (byte) item[startIndex + i].count;
         order[i] = (byte) item[startIndex + i].order;
     }
     int addr;
     MemoryProvider.ReadProcessMemory(windower.pol.Handle, (IntPtr) ((int) windower.pol.BaseAddress + Offset.Get("ORDER_INFO")), &addr, sizeof(int), null);
     fixed (ushort* buf = id) {
         MemoryProvider.WriteProcessMemory(windower.pol.Handle, (IntPtr) (addr + 0x2a + sizeof(ushort)), buf, sizeof(ushort) * 8, null);
     }
     fixed (byte* buf = count) {
         MemoryProvider.WriteProcessMemory(windower.pol.Handle, (IntPtr) (addr + 0x40), buf, sizeof(byte) * 8, null);
     }
     fixed (byte* buf = order) {
         MemoryProvider.WriteProcessMemory(windower.pol.Handle, (IntPtr) (addr + 0x14 + sizeof(byte)), buf, sizeof(byte) * 8, null);
     }
 }
コード例 #37
0
ファイル: Cauldron.cs プロジェクト: hassank/WendyWebVR
    IEnumerator AddItemCo(ObtainableItem item, RecipeItem recipeItem)
    {
        Debug.Log(item+" has been added to the cauldron.");
        ingredientsUsed += 1;
        recipeItem.collected += 1;

        var itemRigidbody = item.GetComponent<Rigidbody>();
        if (itemRigidbody != null) {
            itemRigidbody.useGravity = false;
            itemRigidbody.isKinematic = true;
        }

        LeanTween.move(item.gameObject, transform.position + Vector3.up * 1f, 1f).setEase(LeanTweenType.easeOutCubic);

        yield return new WaitForSeconds(1f);

        var targetPosition = pointInside.position;

        LeanTween.move(item.gameObject, targetPosition, 0.5f);

        audioPlayer.PlayOneShotAfterSec(0, 0.25f);

        if (ingredientsUsed == 1 && GetComponent<PlaysAudioRemarkOnRadio>() != null && !potionIsReady)
            GetComponent<PlaysAudioRemarkOnRadio>().Play(0);

        yield return new WaitForSeconds(0.5f);

        foreach (GameObject subscriber in subscribers) {
            subscriber.SendMessage("OnAddToCauldron", recipeItem, SendMessageOptions.DontRequireReceiver);
        }

        item.gameObject.SetActive(false);
        isAbleToInteract = true;

        if (potionIsReady)
            GivePotion();
    }
コード例 #38
0
        private string AddPrivateRecipeItem(Command command)
        {
            var itemDesc = command.MainObjPair.Value;
            if (string.IsNullOrEmpty(itemDesc)) return "Item cannot be empty";

            if (command.OptionalCommandPairs == null || command.OptionalCommandPairs.Count == 0)
            {
                return "Add item must associate with a recipe";
            }

            int recipeId;
            if (int.TryParse(command.OptionalCommandPairs[0].Value, out recipeId) == false)
            {
                return "Add item must specify a recipe ID";
            }

            var recipe = _privateRecipeRepository.GetById(recipeId);
            if (recipe == null) return $"Recipe with ID [{recipeId}] not found";

            var item = new RecipeItem(itemDesc, recipe);
            recipe.Add(item);
            _privateRecipeRepository.Update(recipe);
            return "Item created successfully";
        }
コード例 #39
0
ファイル: WindowShop.cs プロジェクト: Kinderril/p3
 public void OpenCraft(RecipeItem recipe)
 {
     CraftWindow.Init(recipe, OnCraftComplete);
 }
コード例 #40
0
ファイル: CraftInfoPlace.cs プロジェクト: Kinderril/p3
    public void Init(RecipeItem recipeItem,CatalysItemType? type)
    {
        Utils.ClearTransform(LayoutSpecials);
        var totalPoints = Formuls.GetPlayerItemPointsByLvl(recipeItem.Level) * Formuls.GetSlotCoef(recipeItem.recipeSlot);
        float min;
        float max;
        switch (recipeItem.recipeSlot)
        {
            case Slot.physical_weapon:
            case Slot.magic_weapon:
                if (type.HasValue)
                {
                    var spedAbilities = RecipeItem.PosibleAbilities(type.Value);
                    foreach (var specialAbility in spedAbilities)
                    {
                        var icon = DataBaseController.Instance.SpecialAbilityIcon(specialAbility);
                        var img = Instantiate(PrefabSpecialIcon).GetComponent<Image>();
                        img.sprite = icon;
                        img.transform.SetParent(LayoutSpecials,false);
                    }
                }
                min = totalPoints * 0.5f;
                max = totalPoints;
                MainParameterField.text = min.ToString("0") + " - " + max.ToString("0");
                switch (recipeItem.recipeSlot)
                {
                    case Slot.physical_weapon:
                        MainParameterIcon.sprite = DataBaseController.Instance.ParameterIcon(ParamType.PPower);
                        break;
                    case Slot.magic_weapon:
                        MainParameterIcon.sprite = DataBaseController.Instance.ParameterIcon(ParamType.MPower);
                        break;
                }
                
                break;
            case Slot.body:
            case Slot.helm:

                min = totalPoints * 0.5f;
                max = totalPoints;
                switch (recipeItem.recipeSlot)
                {
                    case Slot.body:
                        MainParameterIcon.sprite = DataBaseController.Instance.ParameterIcon(ParamType.PDef);
                        break;
                    case Slot.helm:
                        MainParameterIcon.sprite = DataBaseController.Instance.ParameterIcon(ParamType.MDef);
                        break;
                }
                var secondary = HeroShopRandomItem.GetSecondaryParam(totalPoints, recipeItem.recipeSlot);
                var prm = Instantiate(PrefabSecondaryParam);
                var img2 = prm.GetComponent<Image>();
                var filed = prm.GetComponentInChildren<Text>();
                var minS = secondary.Value*0.5f;
                var maxS = secondary.Value;
                MainParameterField.text = min.ToString("0") + " - " + max.ToString("0");
                string info = "";
                Sprite spr = null;
                if (type.HasValue)
                {
                    switch (type.Value)
                    {
                        case CatalysItemType.red:
                            min *= 1.25f;
                            max *= 1.25f;
                            MainParameterField.text = min.ToString("0") + " - " + max.ToString("0");
                            break;
                        case CatalysItemType.blue:
                            break;
                        case CatalysItemType.green:
                            info = "Chance to get new talisman.";
                            break;
                        case CatalysItemType.black:
                            min *= 1f;
                            max *= 1.5f;
                            MainParameterField.text = min.ToString("0") + " - " + max.ToString("0");
                            break;
                        case CatalysItemType.white:
                            info = "cost x2";
                            spr = DataBaseController.Instance.ItemIcon(ItemId.money);
                            break;
                    }
                }
                else
                {
                    info = minS.ToString("0") + " - " + maxS.ToString("0");
                    spr = DataBaseController.Instance.ParameterIcon(secondary.Key);
                }


                filed.text = info;
                if (spr == null)
                {
                    img2.enabled = false;
                }
                img2.sprite = spr;
                img2.transform.SetParent(LayoutSpecials, false);

                break;
            case Slot.Talisman:
                break;
        }
    }
コード例 #41
0
ファイル: Craft.cs プロジェクト: anondev/XIACE
 public object Clone()
 {
     RecipeItem item = new RecipeItem();
     item.id = this.id;
     item.count = this.count;
     item.name = this.name;
     item.check = this.check;
     return item;
 }
コード例 #42
0
        public void InsertShouldInsertItemAtSpecifiedIndex()
        {
            var sut = new PrivateRecipe(_author, _title);
            var recipeItem1 = new RecipeItem(_itemDescription, sut);
            var recipeItem2 = new RecipeItem(_itemDescription, sut);

            sut.Add(recipeItem1);
            sut.Insert(recipeItem2, 0);

            sut.Items[0].ShouldBeSameAs(recipeItem2);
        }
コード例 #43
0
 public RecipeItemViewModel(RecipeItem model, IWorkspace workspace, IInventoryService inventoryService)
 {
     Model = model;
     _workspace = workspace;
     _inventoryService = inventoryService;
 }
コード例 #44
0
        public void RemoveShouldRemoveItem()
        {
            var sut = new PrivateRecipe(_author, _title);
            var recipeItem1 = new RecipeItem(_itemDescription, sut);
            var recipeItem2 = new RecipeItem(_itemDescription, sut);
            sut.Add(recipeItem1);
            sut.Add(recipeItem2);

            sut.Remove(recipeItem1);

            sut.Items.Count.ShouldEqual(1);
            sut.Items[0].ShouldBeSameAs(recipeItem2);
        }
コード例 #45
0
        public void ClearShouldUpdateLastModifiedTime()
        {
            var sut = new PrivateRecipe(_author, _title);
            var recipeItem1 = new RecipeItem(_itemDescription, sut);
            var recipeItem2 = new RecipeItem(_itemDescription, sut);
            sut.Add(recipeItem1);
            sut.Add(recipeItem2);
            var oldTime = sut.TimeLastModified;
            Thread.Sleep(100);

            sut.Clear();
            var newTime = sut.TimeLastModified;

            newTime.ShouldNotEqual(oldTime);
        }