RecursiveCraft/CompoundRecipe.cs at main · Ishigh1/RecursiveCraft · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
using System.Collections.Generic;
using System.Linq;
using Terraria;
using Terraria.ID;
using Terraria.ModLoader;

namespace RecursiveCraft
{
	public class CompoundRecipe : ModRecipe
	{
		public Recipe OverridenRecipe;
		public int RecipeId;
		public RecipeInfo RecipeInfo;

		public CompoundRecipe(Mod mod) : base(mod)
		{
		}

		public void Apply(int recipeId, RecipeInfo recipeInfo)
		{
			RecipeId = recipeId;
			OverridenRecipe = Main.recipe[recipeId];
			RecipeInfo = recipeInfo;

			createItem.SetDefaults(OverridenRecipe.createItem.type);
			createItem.stack = OverridenRecipe.createItem.stack * recipeInfo.RecipeUsed[OverridenRecipe];

			if (recipeInfo.UsedItems.Count > requiredItem.Length)
			{
				if (recipeInfo.UsedItems.Count > maxRequirements)
					maxRequirements = recipeInfo.UsedItems.Count; //This may be a bit bigger than the needed value
				requiredItem = new Item[maxRequirements];
				requiredTile = new int[maxRequirements];
				for (int j = 0; j < maxRequirements; j++) requiredItem[j] = new Item();
			}

			SetRequiredItems();
			SetRequiredTiles();
		}

		public void SetRequiredItems()
		{
			List<KeyValuePair<int, int>> keyValuePairs = RecipeInfo.UsedItems.ToList();
			int i = 0;
			foreach (KeyValuePair<int, int> keyValuePair in keyValuePairs.Where(keyValuePair => keyValuePair.Value > 0))
			{
				requiredItem[i].SetDefaults(keyValuePair.Key);
				requiredItem[i].stack = keyValuePair.Value;
				++i;
			}

			for (; i < requiredItem.Length; i++) requiredItem[i].type = ItemID.None;
		}

		public void SetRequiredTiles()
		{
			needWater = false;
			needLava = false;
			needHoney = false;
			needSnowBiome = false;
			Dictionary<Recipe, int> keyValuePairs = RecipeInfo.RecipeUsed;
			int i = 0;
			foreach (Recipe recipe in keyValuePairs.Select(keyValuePair => keyValuePair.Key))
			{
				needWater |= recipe.needWater;
				needLava |= recipe.needLava;
				needHoney |= recipe.needHoney;
				needSnowBiome |= recipe.needSnowBiome;

				foreach (int requiredTile in recipe.requiredTile)
				{
					if (requiredTile == -1) break;
					bool alreadyRequired = false;
					for (int j = 0; j < i; j++)
						if (this.requiredTile[j] == requiredTile)
						{
							alreadyRequired = true;
							break;
						}

					if (!alreadyRequired)
						this.requiredTile[i++] = requiredTile;
				}
			}

			for (; i < requiredTile.Length; i++) requiredTile[i] = -1;
		}

		public override int ConsumeItem(int type, int numRequired)
		{
			return RecipeInfo.TrueUsedItems.TryGetValue(type, out numRequired) ? numRequired : 0;
		}

		public override void OnCraft(Item item)
		{
			List<KeyValuePair<int, int>> keyValuePairs = RecipeInfo.TrueUsedItems.ToList();
			foreach (KeyValuePair<int, int> keyValuePair in keyValuePairs.Where(keyValuePair => keyValuePair.Value < 0))
				Main.LocalPlayer.QuickSpawnItem(keyValuePair.Key, -keyValuePair.Value);

			List<KeyValuePair<Recipe, int>> recipes = RecipeInfo.RecipeUsed.ToList();
			for (int i = 0; i < recipes.Count; i++)
			{
				Recipe recipe = recipes[i].Key;
				int timesCrafted = recipes[i].Value;

				Item targetItem;
				if (i == 0)
				{
					targetItem = item;
				}
				else
				{
					targetItem = new Item();
					targetItem.SetDefaults(recipe.createItem.type);
					targetItem.stack = recipe.createItem.stack;
				}

				for (int j = 0; j < timesCrafted; j++)
				{
					RecipeHooks.OnCraft(targetItem, recipe);
					ItemLoader.OnCraft(targetItem, recipe);

					//This still doesn't take into account any OnCraft editing intermediate recipe result
				}
			}
		}
	}
}