View difference between Paste ID: fsX72rE7 and bUmZQVgW

 // Replaces the existing calcTotalrecursive-Method
 function calcTotalRecursive() {
-    var type, id, req, i, j;
+    var type, id, req, i, amountMissingProducts, j;
     try {
         if (DEVMODE_FUNCTION) {
             var trackingHandle = tracking.start("berater", "calcTotalRecursive", []);
         }
 
         totalRecursive = new Array(new Object(), new Object(), new Object(), new Object());
         // Type is set to '1', so only forestry products are inspected
         type = 1;
 
         // Iterate over all products starting with those which are no pre-product. It is important that an inspected product won't be needed by a non-yet-inspected product!
         for (i = prodNameSort[type].length - 1; i >= 0; i--) {
             // Id of currently inspected product
             id = prodNameSort[type][i];
 
-            // If this product is directly or recursivly needed...
+            /** Calculate the amount of missing products:
-            if (prodMinRack[type][id] > 0 || totalRecursive[type][id] > 0) {
+			 *	- Amount of directly needed product and currently in production in 'prodMinRack'
 			 *	- Amount of recursivly needed product in 'totalRecursive'
 			 *	- Amount of already produced/existing product in stock in 'ProdStock'
              */
             amountMissingProducts = prodMinRack[type][id] + (totalRecursive[type][id] ? totalRecursive[type][id] : 0) - prodStock[type][id];
 
             // If there is a need to gain this product...
             if (amountMissingProducts > 0) {
                 // If this product requires other products... (e.g. tree logs DON'T!)
                 if (prodRequire[type][id]) {
                     // Iterate over pre-products
                     for (j = 0; j < prodRequire[type][id].length; j++) {
-                        /**
+
-                    	 * Some real magic is done here: We calculate, how many pre-products are recursivly needed!
+
-                    	 * - At first, we add the directly and recursivly needed products. If the latter not initialized, we assume 0.
+
-                    	 * - Second, we divide the sum by the amount yielded product per production cycle, e.g. a 'Waschzuber' is 1 and 'Bretter (Gemeine
+
-                    	 *		Fichte)' is 5.
+
-                    	 * - Third, we (should) multiply the result by the amount of products needed to initiate the production process.
+
-                    	 * - Fourth, we round up to the next integer, because we can't spend fractions of pre-products.
+
-                    	 * - At last, we sometimes don't want to round to the next integer, but to the next number e.g. dividable by 5. For instance, the
+                        /** Some real magic is done here: We calculate, how many pre-products are recursivly needed!
-                         * 		production process of 30 'Bonbons' needs 5 'Honig' to start. The formula therefore would be: Math.ceil(x / 5) * 5, where
+                    	 *	We know the amount to produce ('amountMissingProducts') and divide it by the yielded amount per production
-                         * 		x is our result of third. As the mathematicians might have recognized, we can reduce req[2] (amount of products needed to
+                    	 *	cycle ('prodYield'). Then we (should) multiply with the amount of needed pre-product ('req[2]') to initiate
-                         * 		initiate the production process).
+                    	 *	the production. Finally, we round up, since we can't produce fractions ('Math.ceil()').
                     	 *	If the production needs more than one unit of the pre-product, we need to round up to a multiple of 'req[2]'.
-                        totalRecursive[req[0]][req[1]] += Math.ceil((prodMinRack[type][id] + (totalRecursive[type][id] ? totalRecursive[type][id] : 0)) / prodYield[type][id]) * req[2]; // Anzahl rekursiv benötigte Stämme = (direkt + rekursiv benötigte Bretter) / Bretter je Stamm
+                    	 *	The formula therefore is 'Math.ceil(x / req[2]) * req[2]'. We then reduce 'req[2]' inside the ceiling-function.
                     	 */
                         totalRecursive[req[0]][req[1]] += Math.ceil((amountMissingProducts) / prodYield[type][id]) * req[2]; // Anzahl rekursiv benötigte Stämme = (direkt + rekursiv benötigte Bretter) / Bretter je Stamm
                     }
                 }
             }
         }
         if (DEVMODE_FUNCTION) {
             tracking.end("berater", trackingHandle);
         }
     } catch (err) {
         GM_logError("calcTotalRecursive\ntype=" + type + " id=" + id + " req=" + implode(req) + " i=" + i + " j=" + j + "\n" + err);
     }
 }
 
 // In 'function calcProdMinRack(caller)', the call of calcTotalRecursive must be fitted to the new signiture
 if (valMinRackRecursive) {
 	calcTotalRecursive(); // recursive need products calculation
 	// Some iteration over variable totalRecursive to adjust prodMinRack
 }
 
 // German menu-item translation in function startScript()
 texte["de"]["settings_valMinRackRecursive"] = ["Rekursive Produkte", "Berechne die rekursiv benötigten Produkte (in der Baumerei) und addiere sie zur Liste der (direkt) benötigten Produkte hinzu."];