Cubing.js Still doesnt craft

[Tektic]

I've made a bunch of updates for the rune and gem stacks but still no luck with crafting.
Maybe someone can see what im missing still?
`/**

• @filename Cubing.js
• @author kolton Tektic edit PD2
• @desc 3-17-21 / edit for stacks in craft /
  */

var Roll = {
All: 0,
Eth: 1,
NonEth: 2
};

var Recipe = {
Gem: 0,
HitPower: {
Helm: 1,
Boots: 2,
Gloves: 3,
Belt: 4,
Shield: 5,
Body: 6,
Amulet: 7,
Ring: 8,
Weapon: 9
},
Blood: {
Helm: 10,
Boots: 11,
Gloves: 12,
Belt: 13,
Shield: 14,
Body: 15,
Amulet: 16,
Ring: 17,
Weapon: 18
},
Caster: {
Helm: 19,
Boots: 20,
Gloves: 21,
Belt: 22,
Shield: 23,
Body: 24,
Amulet: 25,
Ring: 26,
Weapon: 27
},
Safety: {
Helm: 28,
Boots: 29,
Gloves: 30,
Belt: 31,
Shield: 32,
Body: 33,
Amulet: 34,
Ring: 35,
Weapon: 36
},
Unique: {
Weapon: {
ToExceptional: 37,
ToElite: 38
},
Armor: {
ToExceptional: 39,
ToElite: 40
}
},
Rare: {
Weapon: {
ToExceptional: 41,
ToElite: 42
},
Armor: {
ToExceptional: 43,
ToElite: 44
}
},
Socket: {
Shield: 45,
Weapon: 46,
Armor: 47,
Helm: 48
},
Reroll: {
Magic: 49,
Rare: 50,
HighRare: 51
},
Rune: 52,
Token: 53,
LowToNorm: {
Armor: 54,
Weapon: 55
}
};

var Cubing = {
recipes: [],
gemList: [],

init: function () {
	if (!Config.Cubing) {
		return;
	}

	print("We have " + Config.Recipes.length + " cubing recipe(s).");

	var i;

	for (i = 0; i < Config.Recipes.length; i += 1) {
		if (Config.Recipes[i].length > 1 && isNaN(Config.Recipes[i][1])) {
			if (NTIPAliasClassID.hasOwnProperty(Config.Recipes[i][1].replace(/\s+/g, "").toLowerCase())) {
				Config.Recipes[i][1] = NTIPAliasClassID[Config.Recipes[i][1].replace(/\s+/g, "").toLowerCase()];
			} else {
				Misc.errorReport("ÿc1Invalid cubing entry:ÿc0 " + Config.Recipes[i][1]);
				Config.Recipes.splice(i, 1);

				i -= 1;
			}
		}
	}

	this.buildRecipes();
	this.buildGemList();
	this.buildLists();
},

buildGemList: function () {
	var i, j,
		gemList = [561, 566, 571, 576, 581, 586, 601, 670, 672, 674, 676, 678, 680, 682];

	for (i = 0; i < this.recipes.length; i += 1) {
		if ([0, 49].indexOf(this.recipes[i].Index) === -1) { // Skip gems and other magic rerolling recipes
			for (j = 0; j < this.recipes[i].Ingredients.length; j += 1) {
				if (gemList.indexOf(this.recipes[i].Ingredients[j]) > -1) {
					gemList.splice(gemList.indexOf(this.recipes[i].Ingredients[j]), 1);
				}
			}
		}
	}

	this.gemList = gemList.slice(0);

	return true;
},

getCube: function () {
	// Don't activate from townchicken
	if (getScript(true).name === "tools\\townchicken.js") {
		return false;
	}

	var i, cube, chest;

	Pather.useWaypoint(57, true);
	Precast.doPrecast(true);

	if (Pather.moveToExit(60, true) && Pather.moveToPreset(me.area, 2, 354)) {
		chest = getUnit(2, 354);

		if (chest) {
			Misc.openChest(chest);

			for (i = 0; i < 5; i += 1) {
				cube = getUnit(4, 549);

				if (cube) {
					Pickit.pickItem(cube);

					break;
				}

				delay(200);
			}
		}
	}

	Town.goToTown();

	cube = me.getItem(549);

	if (cube) {
		return Storage.Stash.MoveTo(cube);
	}

	return false;
},

buildRecipes: function () {
	var i;

	this.recipes = [];

	for (i = 0; i < Config.Recipes.length; i += 1) {
		if (typeof Config.Recipes[i] !== "object" || (Config.Recipes[i].length > 2 && typeof Config.Recipes[i][2] !== "number") || Config.Recipes[i].length < 1) {
			throw new Error("Cubing.buildRecipes: Invalid recipe format.");
		}

		switch (Config.Recipes[i][0]) {			
		case Recipe.Gem:
			switch (Config.Recipes[i][1]) {
			case 669: // flawless amethyst stack
			case 671: // flawless topaz stack
			case 673: // flawless sapphire stack
			case 675: // flawless emerald stack
			case 677: // flawless ruby stack
			case 679: // flawless diamond stack
			case 681: // flawless skull stack
				this.recipes.push({Ingredients: [Config.Recipes[i][1], 543], Index: Recipe.Gem, AlwaysEnabled: true});

				break;
			}

			break;
		case Recipe.HitPower.Helm:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 688, 643, 674], Level: 84, Index: Recipe.HitPower.Helm});

			break;
		case Recipe.HitPower.Boots:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 690, 643, 674], Level: 71, Index: Recipe.HitPower.Boots});

			break;
		case Recipe.HitPower.Gloves:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 691, 643, 674], Level: 79, Index: Recipe.HitPower.Gloves});

			break;
		case Recipe.HitPower.Belt:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 689, 643, 674], Level: 71, Index: Recipe.HitPower.Belt});

			break;
		case Recipe.HitPower.Shield:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 687, 643, 674], Level: 82, Index: Recipe.HitPower.Shield});

			break;
		case Recipe.HitPower.Body:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 686, 643, 674], Level: 85, Index: Recipe.HitPower.Body});

			break;
		case Recipe.HitPower.Amulet:
			this.recipes.push({Ingredients: [520, 692, 643, 674], Level: 90, Index: Recipe.HitPower.Amulet});

			break;
		case Recipe.HitPower.Ring:
			this.recipes.push({Ingredients: [522, 693, 643, 674], Level: 77, Index: Recipe.HitPower.Ring});

			break;
		case Recipe.HitPower.Weapon:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 685, 643, 674], Level: 85, Index: Recipe.HitPower.Weapon});

			break;
		case Recipe.Blood.Helm:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 690, 643, 678], Level: 84, Index: Recipe.Blood.Helm});

			break;
		case Recipe.Blood.Boots:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 687, 643, 678], Level: 71, Index: Recipe.Blood.Boots});

			break;
		case Recipe.Blood.Gloves:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 686, 643, 678], Level: 79, Index: Recipe.Blood.Gloves});

			break;
		case Recipe.Blood.Belt:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 689, 643, 678], Level: 71, Index: Recipe.Blood.Belt});

			break;
		case Recipe.Blood.Shield:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 688, 643, 678], Level: 82, Index: Recipe.Blood.Shield});

			break;
		case Recipe.Blood.Body:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 692, 643, 678], Level: 85, Index: Recipe.Blood.Body});

			break;
		case Recipe.Blood.Amulet:
			this.recipes.push({Ingredients: [520, 693, 643, 678], Level: 90, Index: Recipe.Blood.Amulet});

			break;
		case Recipe.Blood.Ring:
			this.recipes.push({Ingredients: [522, 694, 643, 678], Level: 77, Index: Recipe.Blood.Ring});

			break;
		case Recipe.Blood.Weapon:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 691, 643, 678], Level: 85, Index: Recipe.Blood.Weapon});

			break;
		case Recipe.Caster.Helm:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 686, 643, 670], Level: 84, Index: Recipe.Caster.Helm});

			break;
		case Recipe.Caster.Boots:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 692, 643, 670], Level: 71, Index: Recipe.Caster.Boots});

			break;
		case Recipe.Caster.Gloves:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 691, 643, 670], Level: 79, Index: Recipe.Caster.Gloves});

			break;
		case Recipe.Caster.Belt:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 688, 643, 670], Level: 71, Index: Recipe.Caster.Belt});

			break;
		case Recipe.Caster.Shield:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 687, 643, 670], Level: 82, Index: Recipe.Caster.Shield});

			break;
		case Recipe.Caster.Body:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 689, 643, 670], Level: 85, Index: Recipe.Caster.Body});

			break;
		case Recipe.Caster.Amulet:
			this.recipes.push({Ingredients: [520, 690, 643, 670], Level: 90, Index: Recipe.Caster.Amulet});

			break;
		case Recipe.Caster.Ring:
			this.recipes.push({Ingredients: [522, 693, 643, 670], Level: 77, Index: Recipe.Caster.Ring});

			break;
		case Recipe.Caster.Weapon:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 685, 643, 670], Level: 85, Index: Recipe.Caster.Weapon});

			break;
		case Recipe.Safety.Helm:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 688, 643, 676], Level: 84, Index: Recipe.Safety.Helm});

			break;
		case Recipe.Safety.Boots:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 691, 643, 676], Level: 71, Index: Recipe.Safety.Boots});

			break;
		case Recipe.Safety.Gloves:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 690, 643, 676], Level: 79, Index: Recipe.Safety.Gloves});

			break;
		case Recipe.Safety.Belt:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 689, 643, 676], Level: 71, Index: Recipe.Safety.Belt});

			break;
		case Recipe.Safety.Shield:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 686, 643, 676], Level: 82, Index: Recipe.Safety.Shield});

			break;
		case Recipe.Safety.Body:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 687, 643, 676], Level: 85, Index: Recipe.Safety.Body});

			break;
		case Recipe.Safety.Amulet:
			this.recipes.push({Ingredients: [520, 692, 643, 676], Level: 90, Index: Recipe.Safety.Amulet});

			break;
		case Recipe.Safety.Ring:
			this.recipes.push({Ingredients: [522, 693, 643, 676], Level: 77, Index: Recipe.Safety.Ring});

			break;
		case Recipe.Safety.Weapon:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 694, 643, 676], Level: 85, Index: Recipe.Safety.Weapon});

			break;
		case Recipe.Unique.Weapon.ToExceptional:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 690, 694, 676], Index: Recipe.Unique.Weapon.ToExceptional, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Unique.Weapon.ToElite: // Ladder only
			if (me.ladder) {
				this.recipes.push({Ingredients: [Config.Recipes[i][1], 699, 703, 676], Index: Recipe.Unique.Weapon.ToElite, Ethereal: Config.Recipes[i][2]});
			}

			break;
		case Recipe.Unique.Armor.ToExceptional:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 689, 695, 680], Index: Recipe.Unique.Armor.ToExceptional, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Unique.Armor.ToElite: // Ladder only
			if (me.ladder) {
				this.recipes.push({Ingredients: [Config.Recipes[i][1], 702, 700, 680], Index: Recipe.Unique.Armor.ToElite, Ethereal: Config.Recipes[i][2]});
			}

			break;
		case Recipe.Rare.Weapon.ToExceptional:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 691, 693, 674], Index: Recipe.Rare.Weapon.ToExceptional, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Rare.Weapon.ToElite:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 701, 704, 674], Index: Recipe.Rare.Weapon.ToElite, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Rare.Armor.ToExceptional:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 690, 692, 670], Index: Recipe.Rare.Armor.ToExceptional, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Rare.Armor.ToElite:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 700, 703, 670], Index: Recipe.Rare.Armor.ToElite, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Socket.Shield:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 689, 693, 678], Index: Recipe.Socket.Shield, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Socket.Weapon:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 690, 693, 670], Index: Recipe.Socket.Weapon, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Socket.Armor:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 689, 692, 672], Index: Recipe.Socket.Armor, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Socket.Helm:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 690, 692, 674], Index: Recipe.Socket.Helm, Ethereal: Config.Recipes[i][2]});

			break;
		case Recipe.Reroll.Magic: // Hacky solution ftw
			this.recipes.push({Ingredients: [Config.Recipes[i][1], "pgem", "pgem", "pgem"], Level: 91, Index: Recipe.Reroll.Magic});

			break;
		case Recipe.Reroll.Rare:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 601, 601, 601, 601, 601, 601], Index: Recipe.Reroll.Rare});

			break;
		case Recipe.Reroll.HighRare:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 601, 522], Index: Recipe.Reroll.HighRare, Enabled: false});

			break;
		case Recipe.LowToNorm.Weapon:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 684, "cgem"], Index: Recipe.LowToNorm.Weapon});

			break;
		case Recipe.LowToNorm.Armor:
			this.recipes.push({Ingredients: [Config.Recipes[i][1], 683, "cgem"], Index: Recipe.LowToNorm.Armor});

			break;
		case Recipe.Rune:
			switch (Config.Recipes[i][1]) {
			case 610: // el
			case 611: // eld
			case 612: // tir
			case 613: // nef
			case 614: // eth
			case 615: // ith
			case 616: // tal
			case 617: // ral
			case 618: // ort
				this.recipes.push({Ingredients: [Config.Recipes[i][1], Config.Recipes[i][1], Config.Recipes[i][1]], Index: Recipe.Rune, AlwaysEnabled: true});

				break;
			case 619: // thul->amn
				this.recipes.push({Ingredients: [619, 619, 619, 562], Index: Recipe.Rune});

				break;
			case 620: // amn->sol
				this.recipes.push({Ingredients: [620, 620, 620, 557], Index: Recipe.Rune});

				break;
			case 621: // sol->shael
				this.recipes.push({Ingredients: [621, 621, 621, 567], Index: Recipe.Rune});

				break;
			case 622: // shael->dol
				this.recipes.push({Ingredients: [622, 622, 622, 577], Index: Recipe.Rune});

				break;
			case 623: // dol->hel
				if (me.ladder) {
					this.recipes.push({Ingredients: [623, 623, 623, 572], Index: Recipe.Rune});
				}

				break;
			case 624: // hel->io
				if (me.ladder) {
					this.recipes.push({Ingredients: [624, 624, 624, 582], Index: Recipe.Rune});
				}

				break;
			case 625: // io->lum
				if (me.ladder) {
					this.recipes.push({Ingredients: [625, 625, 625, 563], Index: Recipe.Rune});
				}

				break;
			case 626: // lum->ko
				if (me.ladder) {
					this.recipes.push({Ingredients: [626, 626, 626, 558], Index: Recipe.Rune});
				}

				break;
			case 627: // ko->fal
				if (me.ladder) {
					this.recipes.push({Ingredients: [627, 627, 627, 568], Index: Recipe.Rune});
				}

				break;
			case 628: // fal->lem
				if (me.ladder) {
					this.recipes.push({Ingredients: [628, 628, 628, 578], Index: Recipe.Rune});
				}

				break;
			case 629: // lem->pul
				if (me.ladder) {
					this.recipes.push({Ingredients: [629, 629, 629, 573], Index: Recipe.Rune});
				}

				break;
			case 630: // pul->um
				if (me.ladder) {
					this.recipes.push({Ingredients: [630, 630, 583], Index: Recipe.Rune});
				}

				break;
			case 631: // um->mal
				if (me.ladder) {
					this.recipes.push({Ingredients: [631, 631, 564], Index: Recipe.Rune});
				}

				break;
			case 632: // mal->ist
				if (me.ladder) {
					this.recipes.push({Ingredients: [632, 632, 559], Index: Recipe.Rune});
				}

				break;
			case 633: // ist->gul
				if (me.ladder) {
					this.recipes.push({Ingredients: [633, 633, 569], Index: Recipe.Rune});
				}

				break;
			case 634: // gul->vex
				if (me.ladder) {
					this.recipes.push({Ingredients: [634, 634, 579], Index: Recipe.Rune});
				}

				break;
			case 635: // vex->ohm
				if (me.ladder) {
					this.recipes.push({Ingredients: [635, 635, 574], Index: Recipe.Rune});
				}

				break;
			case 636: // ohm->lo
				if (me.ladder) {
					this.recipes.push({Ingredients: [636, 636, 584], Index: Recipe.Rune});
				}

				break;
			case 637: // lo->sur
				if (me.ladder) {
					this.recipes.push({Ingredients: [637, 637, 565], Index: Recipe.Rune});
				}

				break;
			case 638: // sur->ber
				if (me.ladder) {
					this.recipes.push({Ingredients: [638, 638, 560], Index: Recipe.Rune});
				}

				break;
			case 639: // ber->jah
				if (me.ladder) {
					this.recipes.push({Ingredients: [639, 639, 570], Index: Recipe.Rune});
				}

				break;
			case 640: // jah->cham
				if (me.ladder) {
					this.recipes.push({Ingredients: [640, 640, 580], Index: Recipe.Rune});
				}

				break;
			case 641: // cham->zod
				if (me.ladder) {
					this.recipes.push({Ingredients: [641, 641, 575], Index: Recipe.Rune});
				}

				break;		

			//PD2 Low Rune Stacks (3 Runes + Key)
			case 683: //El > Eld
			case 684: //Eld > Tir
			case 685: //Tir > Nef
			case 686: //Nef > Eth
			case 687: //Eth > Ith
			case 688: //Ith > Tal
			case 689: //Tal > Ral
			case 690: //Ral > Ort
			case 691: //Ort > Thul
			case 692: //Thul > Amn
			case 693: //Amn > Sol
			case 694: //Sol > Shael
			case 695: //Shael > Dol
			case 696: //Dol > Hel
			case 697: //Hel > Io
			case 698: //Io > Lum
			case 699: //Lum > Ko
			case 700: //Ko > Fal
			case 701: //Fal > Lem
			case 702: //Lem > Pul
				this.recipes.push({Ingredients: [Config.Recipes[i][1], 543], Index: Recipe.Rune});
				break;
			//PD2 Mid/High Rune Stacks (2 Runes + Key)	
			case 703: //Pul > Um
			case 704: //Um > Mal
			case 705: //Mal > Ist
			case 706: //Ist > Gul
			case 707: //Gul > Vex
			case 708: //Vex > Ohm
			case 709: //Ohm > Lo
			case 710: //Lo > Sur
			case 711: //Sur > Ber
			case 712: //Ber > Jah
			case 713: //Jah > Cham
			case 714: //Cham > Zod
				this.recipes.push({Ingredients: [Config.Recipes[i][1], 543], Index: Recipe.Rune});
				break;
		}
		break;
		case Recipe.Token:
			this.recipes.push({Ingredients: [654, 655, 656, 657], Index: Recipe.Token, AlwaysEnabled: true});
			break;
		}
	} 
},

validIngredients: [], // What we have
neededIngredients: [], // What we need
subRecipes: [],

buildLists: function () {
	var i, j, k, items;

	CraftingSystem.checkSubrecipes();

	this.validIngredients = [];
	this.neededIngredients = [];
	items = me.findItems(-1, 0);

	for (i = 0; i < this.recipes.length; i += 1) {
		// Set default Enabled property - true if recipe is always enabled, false otherwise
		this.recipes[i].Enabled = this.recipes[i].hasOwnProperty("AlwaysEnabled");

IngredientLoop:
for (j = 0; j < this.recipes[i].Ingredients.length; j += 1) { // Loop thru recipe's ingredients
for (k = 0; k < items.length; k += 1) { // Loop thru items
if (((this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(items[k].classid) > -1) ||
(this.recipes[i].Ingredients[j] === "cgem" && [557, 562, 567, 572, 577, 582, 597].indexOf(items[k].classid) > -1) ||
items[k].classid === this.recipes[i].Ingredients[j]) && this.validItem(items[k], this.recipes[i])) {

					// push the item's info into the valid ingredients array. this will be used to find items when checking recipes
					this.validIngredients.push({classid: items[k].classid, gid: items[k].gid});

					// Remove from item list to prevent counting the same item more than once
					items.splice(k, 1);

					k -= 1;

					// Enable recipes for gem/jewel pickup
					if (this.recipes[i].Index !== Recipe.Rune || (this.recipes[i].Index === Recipe.Rune && j >= 1)) { // Enable rune recipe after 2 bases are found
						this.recipes[i].Enabled = true;
					}

					continue IngredientLoop;
				}
			}

			// add the item to needed list - enable pickup
			this.neededIngredients.push({classid: this.recipes[i].Ingredients[j], recipe: this.recipes[i]});

			// skip flawless gems adding if we don't have the main item (Recipe.Gem and Recipe.Rune for el-ort are always enabled)
			if (!this.recipes[i].Enabled) {
				break;
			}

			// if the recipe is enabled (we have the main item), add flawless gem recipes (if needed)

						
			// Make perf amethyst
			if (this.subRecipes.indexOf(561) === -1 && (this.recipes[i].Ingredients[j] === 561 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(561) > -1))) {
				this.recipes.push({Ingredients: [560, 560, 560], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(561);
			}
			if (this.subRecipes.indexOf(670) === -1 && (this.recipes[i].Ingredients[j] === 670 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(670) > -1))) {
				this.recipes.push({Ingredients: [669, 543], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(670);
			}
			// Make perf topaz
			if (this.subRecipes.indexOf(566) === -1 && (this.recipes[i].Ingredients[j] === 566 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(566) > -1))) {
				this.recipes.push({Ingredients: [565, 565, 565], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(566);
			}
			if (this.subRecipes.indexOf(672) === -1 && (this.recipes[i].Ingredients[j] === 672 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(672) > -1))) {
				this.recipes.push({Ingredients: [671, 543], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(672);
			}
			// Make perf sapphire
			if (this.subRecipes.indexOf(571) === -1 && (this.recipes[i].Ingredients[j] === 571 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(571) > -1))) {
				this.recipes.push({Ingredients: [570, 570, 570], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(571);
			}
			if (this.subRecipes.indexOf(674) === -1 && (this.recipes[i].Ingredients[j] === 674 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(674) > -1))) {
				this.recipes.push({Ingredients: [673, 543], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(674);
			}
			// Make perf emerald
			if (this.subRecipes.indexOf(576) === -1 && (this.recipes[i].Ingredients[j] === 576 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(576) > -1))) {
				this.recipes.push({Ingredients: [575, 575, 575], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(576);
			}
			if (this.subRecipes.indexOf(676) === -1 && (this.recipes[i].Ingredients[j] === 676 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(676) > -1))) {
				this.recipes.push({Ingredients: [675, 543], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(676);
			}
			// Make perf ruby
			if (this.subRecipes.indexOf(581) === -1 && (this.recipes[i].Ingredients[j] === 581 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(581) > -1))) {
				this.recipes.push({Ingredients: [580, 580, 580], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(581);
			}
			if (this.subRecipes.indexOf(678) === -1 && (this.recipes[i].Ingredients[j] === 678 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(678) > -1))) {
				this.recipes.push({Ingredients: [677, 543], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(678);
			}
			// Make perf diamond
			if (this.subRecipes.indexOf(586) === -1 && (this.recipes[i].Ingredients[j] === 586 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(586) > -1))) {
				this.recipes.push({Ingredients: [585, 585, 585], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(586);
			}
			if (this.subRecipes.indexOf(680) === -1 && (this.recipes[i].Ingredients[j] === 680 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(680) > -1))) {
				this.recipes.push({Ingredients: [679, 543], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(680);
			}
			// Make perf skull
			if (this.subRecipes.indexOf(601) === -1 && (this.recipes[i].Ingredients[j] === 601 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(601) > -1))) {
				this.recipes.push({Ingredients: [600, 600, 600], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(601);
			}
			if (this.subRecipes.indexOf(682) === -1 && (this.recipes[i].Ingredients[j] === 682 || (this.recipes[i].Ingredients[j] === "pgem" && this.gemList.indexOf(682) > -1))) {
				this.recipes.push({Ingredients: [681, 543], Index: Recipe.Gem, AlwaysEnabled: true, MainRecipe: this.recipes[i].Index});
				this.subRecipes.push(682);
			}
		}
	}
},

// Remove unneeded flawless gem recipes
clearSubRecipes: function () {
	var i;

	this.subRecipes = [];

	for (i = 0; i < this.recipes.length; i += 1) {
		if (this.recipes[i].hasOwnProperty("MainRecipe")) {
			this.recipes.splice(i, 1);

			i -= 1;
		}
	}
},

update: function () {
	this.clearSubRecipes();
	this.buildLists();

},

checkRecipe: function (recipe) {
	var i, j, item,
		usedGids = [],
		matchList = [];

	for (i = 0; i < recipe.Ingredients.length; i += 1) {
		for (j = 0; j < this.validIngredients.length; j += 1) {
			if (usedGids.indexOf(this.validIngredients[j].gid) === -1 && (
					this.validIngredients[j].classid === recipe.Ingredients[i] ||
					(recipe.Ingredients[i] === "pgem" && this.gemList.indexOf(this.validIngredients[j].classid) > -1) ||
					(recipe.Ingredients[i] === "cgem" && [557, 562, 567, 572, 577, 582, 597].indexOf(this.validIngredients[j].classid) > -1)
				)) {
				item = me.getItem(this.validIngredients[j].classid, -1, this.validIngredients[j].gid);

				if (item && this.validItem(item, recipe)) { // 26.11.2012. check if the item actually belongs to the given recipe
					// don't repeat the same item
					usedGids.push(this.validIngredients[j].gid);
					// push the item into the match list
					matchList.push(copyUnit(item));
					
					break;
				}
			}
		}

		// no new items in the match list = not enough ingredients
		if (matchList.length !== i + 1) {
			return false;
		}
	}

	// return the match list. these items go to cube
	
	return matchList;
},

// debug function - get what each recipe needs
getRecipeNeeds: function (index) {
	var i,
		rval = " [";

	for (i = 0; i < this.neededIngredients.length; i += 1) {
		if (this.neededIngredients[i].recipe.Index === index) {
			rval += this.neededIngredients[i].classid + (i === this.neededIngredients.length - 1 ? "" : " ");
		}
	}

	rval += "]";

	return rval;
},

checkItem: function (unit) { // Check an item on ground for pickup
	if (!Config.Cubing) {
		return false;
	}

	if (this.keepItem(unit)) {
		return true;
	}

	var i;

	for (i = 0; i < this.neededIngredients.length; i += 1) {
		if (unit.classid === this.neededIngredients[i].classid && this.validItem(unit, this.neededIngredients[i].recipe)) {
			//debugLog("Cubing: " + unit.name + " " + this.neededIngredients[i].recipe.Index + " " + (this.neededIngredients[i].recipe.hasOwnProperty("MainRecipe") ? this.neededIngredients[i].recipe.MainRecipe : "") + this.getRecipeNeeds(this.neededIngredients[i].recipe.Index));

			return true;
		}
	}

	return false;
},

keepItem: function (unit) { // Don't drop an item from inventory if it's a part of cubing recipe
	if (!Config.Cubing) {
		return false;
	}

	var i;

	for (i = 0; i < this.validIngredients.length; i += 1) {
		if (unit.mode === 0 && unit.gid === this.validIngredients[i].gid) {
			return true;
		}
	}

	return false;
},

validItem: function (unit, recipe) {
	// Don't use items in locked inventory space
	if (unit.mode === 0 && unit.location === 3 && Storage.Inventory.IsLocked(unit, Config.Inventory)) {
		return false;
	}

	// Excluded items
	if (Runewords.validGids.indexOf(unit.gid) > -1 || CraftingSystem.validGids.indexOf(unit.gid) > -1) {
		return false;
	}

	// Gems and runes
	if ((unit.itemType >= 96 && unit.itemType <= 103) || unit.itemType === 74) {
		if (!recipe.Enabled && recipe.Ingredients [0] !== unit.classid && recipe.Ingredients[1] !== unit.classid) {
			return false;
		}

		return true;
	}

	
	// PD2 Flawless Gems Validation
	if ((unit.itemType >= 149 && unit.itemType <= 155) && unit.getStat(70) >= 3 || unit.itemType == 41) {

/* if (!recipe.Enabled && recipe.Ingredients [0] !== unit.classid && recipe.Ingredients[1] !== unit.classid) {
return false;
} */
return true;
}

	// PD2 - Validate & Quantity Check Low Rune Stack
	if (unit.classid >= 683 && unit.classid <= 703) {
		if(!Config.MinRuneStack && unit.getStat(70) >= 3){
			return true;
		} else if (unit.getStat(70) >= Config.MinRuneStack + 3) {
			return true;
		}	
	}
	
	// PD2 - Validate & Quantity Check Mid/High Rune Stack
	if (unit.classid >= 704 && unit.classid <= 714) {
		if(!Config.MinRuneStack && unit.getStat(70) >= 2){
			return true;
		} else if (unit.getStat(70) >= Config.MinRuneStack + 2) {
			return true;
		}	
	}
	


	if (recipe.Index >= Recipe.HitPower.Helm && recipe.Index <= Recipe.Safety.Weapon) {
		// Junk jewels (NOT matching a pickit entry)
		if (unit.itemType === 643) {
			if (recipe.Enabled && NTIP.CheckItem(unit) === 0) {
				return true;
			}
		// Main item, NOT matching a pickit entry
		} else if (unit.quality === 4 && Math.floor(me.charlvl / 2) + Math.floor(unit.ilvl / 2) >= recipe.Level && NTIP.CheckItem(unit) === 0) {
			return true;
		}

		return false;
	}

	if (recipe.Index >= Recipe.Unique.Weapon.ToExceptional && recipe.Index <= Recipe.Unique.Armor.ToElite) {
		// Unique item matching pickit entry
		if (unit.quality === 7 && NTIP.CheckItem(unit) === 1) {
			switch (recipe.Ethereal) {
			case 0:
			case undefined:
				return NTIP.CheckItem(unit) === 1;
			case 1:
				return unit.getFlag(0x400000) && NTIP.CheckItem(unit) === 1;
			case 2:
				return !unit.getFlag(0x400000) && NTIP.CheckItem(unit) === 1;
			}
		}

		return false;
	}

	if (recipe.Index >= Recipe.Rare.Weapon.ToExceptional && recipe.Index <= Recipe.Rare.Armor.ToElite) {
		// Rare item matching pickit entry
		if (unit.quality === 6 && NTIP.CheckItem(unit) === 1) {
			switch (recipe.Ethereal) {
			case 0:
			case undefined:
				return NTIP.CheckItem(unit) === 1;
			case 1:
				return unit.getFlag(0x400000) && NTIP.CheckItem(unit) === 1;
			case 2:
				return !unit.getFlag(0x400000) && NTIP.CheckItem(unit) === 1;
			}
		}

		return false;
	}

	if (recipe.Index >= Recipe.Socket.Shield && recipe.Index <= Recipe.Socket.Helm) {
		// Normal item matching pickit entry, no sorcets
		if (unit.quality === 2 && unit.getStat(194) === 0) {
			switch (recipe.Ethereal) {
			case 0:
			case undefined:
				return NTIP.CheckItem(unit) === 1;
			case 1:
				return unit.getFlag(0x400000) && NTIP.CheckItem(unit) === 1;
			case 2:
				return !unit.getFlag(0x400000) && NTIP.CheckItem(unit) === 1;
			}
		}

		return false;
	}

	if (recipe.Index === Recipe.Reroll.Magic) {
		if (unit.quality === 4 && unit.ilvl >= recipe.Level && NTIP.CheckItem(unit) === 0) {
			return true;
		}

		return false;
	}

	if (recipe.Index === Recipe.Reroll.Rare) {
		if (unit.quality === 6 && NTIP.CheckItem(unit) === 0) {
			return true;
		}

		return false;
	}

	if (recipe.Index === Recipe.Reroll.HighRare) {
		if (recipe.Ingredients[0] === unit.classid && unit.quality === 6 && NTIP.CheckItem(unit) === 0) {
			recipe.Enabled = true;

			return true;
		}

		if (recipe.Enabled && recipe.Ingredients[2] === unit.classid && unit.itemType === 10 && unit.getStat(77) && !Storage.Inventory.IsLocked(unit, Config.Inventory)) {
			return true;
		}

		return false;
	}

	if (recipe.Index === Recipe.LowToNorm.Armor || recipe.Index === Recipe.LowToNorm.Weapon) {
		if (unit.quality === 1 && NTIP.CheckItem(unit) === 0) {
			return true;
		}

		return false;
	}

	if (recipe.Index === Recipe.Token) {
		return true;
	}

	return false;
},

doCubing: function () {
	if (!Config.Cubing) {
		return false;
	}

	if (!me.getItem(549) && !this.getCube()) { // Check if char has cube
		return false;
	}

	var i, j, items, string, result, tempArray;

	this.update();
	// Randomize the recipe array to prevent recipe blocking (multiple caster items etc.)
	tempArray = this.recipes.slice().shuffle();
	
	for (i = 0; i < tempArray.length; i += 1) {
		string = "Transmuting: ";
		items = this.checkRecipe(tempArray[i]);

		if (items) {
			// If cube isn't open, attempt to open stash (the function returns true if stash is already open)
			if ((!getUIFlag(0x1a) && !Town.openStash()) || !this.emptyCube()) {
				return false;
			}

			this.cursorCheck();

			i = -1;

			while (items.length) {
				string += (items[0].name.trim() + (items.length > 1 ? " + " : ""));
				Storage.Cube.MoveTo(items[0]);
				items.shift();
			}

			if (!this.openCube()) {
				return false;
			}

			transmute();
			delay(700 + me.ping);
			print("ÿc4Cubing: " + string);

			if (Config.ShowCubingInfo) {
				D2Bot.printToConsole(string, 5);
			}

			this.update();

			items = me.findItems(-1, -1, 6);

			if (items) {
				for (j = 0; j < items.length; j += 1) {
				
					if(this.validIngredients.indexOf(items[j].classid)){
						Storage.Inventory.MoveTo(items[j]);
					} else {
						result = Pickit.checkItem(items[j]);

						switch (result.result) {
						case 0:
						if(!items[j].classid == 549){
							Misc.itemLogger("Dropped", items[j], "doCubing");
							items[j].drop();
						}

							break;
						case 1:
							Misc.itemLogger("Cubing Kept", items[j]);
							Misc.logItem("Cubing Kept", items[j], result.line);

							break;
						case 5: // Crafting System
							CraftingSystem.update(items[j]);

							break;
						} 
					}
				}
			}

			if (!this.emptyCube()) {
				break;
			}
		}
	}

	if (getUIFlag(0x1A) || getUIFlag(0x19)) {
		delay(1000);

		while (getUIFlag(0x1A) || getUIFlag(0x19)) {
			me.cancel();
			delay(300);
		}
	}

	return true;
},

cursorCheck: function () {
	var item;

	if (me.itemoncursor) {
		item = getUnit(100);

		if (item) {
			if (Storage.Inventory.CanFit(item) && Storage.Inventory.MoveTo(item)) {
				return true;
			}

			if (Storage.Stash.CanFit(item) && Storage.Stash.MoveTo(item)) {
				return true;
			}

			Misc.itemLogger("Dropped", item, "cursorCheck");

			if (item.drop()) {
				return true;
			}
		}

		return false;
	}

	return true;
},

openCube: function () {
	var i, tick,
		cube = me.getItem(549);

	if (!cube) {
		return false;
	}

	if (getUIFlag(0x1a)) {
		return true;
	}

	if (cube.location === 7 && !Town.openStash()) {
		return false;
	}

	for (i = 0; i < 3; i += 1) {
		cube.interact();
		tick = getTickCount();

		while (getTickCount() - tick < 5000) {
			if (getUIFlag(0x1a)) {
				delay(100 + me.ping * 2); // allow UI to initialize

				return true;
			}

			delay(100);
		}
	}

	return false;
},

closeCube: function () {
	var i, tick;

	if (!getUIFlag(0x1a)) {
		return true;
	}

	for (i = 0; i < 5; i++) {
		me.cancel();
		tick = getTickCount();

		while (getTickCount() - tick < 3000) {
			if (!getUIFlag(0x1a)) {
				delay(250 + me.ping * 2); // allow UI to initialize
				return true;
			}

			delay(100);
		}
	}

	return false;
},

emptyCube: function () {
	var cube = me.getItem(549),
		items = me.findItems(-1, -1, 6);

	if (!cube) {
		return false;
	}

	if (!items) {
		return true;
	}

	while (items.length) {
		if (!Storage.Stash.MoveTo(items[0]) && !Storage.Inventory.MoveTo(items[0])) {
			return false;
		}

		items.shift();
	}

	return true;
},

makeRevPots: function () {
	let locations = {
			Belt: 2,
			Inventory: 3,
			Cube: 6,
			Stash: 7,
		},
		origin = [], cube = me.getItem(549/* the cube it self*/), cubeInStash;

	// Get a list of all items
	let revpots = me.getItems()
		.filter(item => item.classid === 515); // Filter out all those rev pots

	// Stop if less as 3 pots
	if (revpots.length < 3) {
		return;
	}

	// Go to town and open stash
	Town.goToTown() && Town.moveToSpot('stash');
	Town.openStash();

	// For reasons unclear, cubing goes wrong in stash in my test, so for ease, i put cube in inventory
	(cubeInStash = cube.location !== locations.Inventory) && Storage.Inventory.MoveTo(cube);
	me.cancel();
	me.cancel();

	// clear the cube, otherwise we cant transmute
	Cubing.emptyCube();

	// Remove excessive pots from the list. (only groups of 3)
	revpots.length -= revpots.length % 3;

	// Call this function for each pot
	revpots.forEach(function (pot, index) {

		// Add this to the original location array
		origin.push({location: pot.location, x: pot.x, y: pot.y});

		Town.openStash();

		// Move to inventory first (to avoid bugs)
		Storage.Inventory.MoveTo(pot);
		me.cancel(); // remove inventory/cube window
		me.cancel(); // remove inventory window (if it was cube)

		// Move the current pot to the cube
		Storage.Cube.MoveTo(pot);
		// For every third pot, excluding the first
		if (!index || (1 + index) % 3 !== 0) {
			me.cancel(); // remove cube window
			me.cancel(); // remove stash window
		} else {
			// press the transmute button
			Cubing.openCube() && transmute();

			// high delay here to avoid issues with ping spikes
			delay(me.ping * 5 + 1000); // <-- probably can be less

			// Find all items in the cube. (the full rev pot)
			let fullrev = me.findItem(-1, -1, 6);

			// Sort the original locations of the pots. Put a low location first (belt = 2, rest is higher).
			origin.sort((a, b) => a.location - b.location).some(function (orgin) { // Loop over all the original spots.

				// Loop trough all possible locations
				for (let i in locations) {
					// If location is matched with its orgin, we know the name of the spot
					locations[i] === orgin.location && (orgin.location = i); // Store the name of the location
				}

				Storage.Inventory.MoveTo(fullrev); // First put to inventory;
				me.cancel(); // cube
				me.cancel(); // inventory

				// If the storage location is known, put the pot to this location
				Storage[orgin.location] && Storage[orgin.location].moveTo(fullrev);

				// If returned true, the prototype some stops looping.
				return fullrev.location !== locations.Cube;
			});

			// empty the array
			origin.length = 0;

			// Cube should be empty, but lets be sure
			Cubing.emptyCube();
		}
	});
	// Put cube back in stash, if it was when we started
	cubeInStash && Storage.Stash.MoveTo(cube);

	me.cancel();
	me.cancel();
},

};`

[yayza]

Can you upload to pastebin so I can download and compare.

[Borega]

its seems ur not working with the version from the repo. Pls use that. it should work

[Tektic]

Its all working now? cool. i didn't know.

…

On Sat, Mar 27, 2021 at 5:55 AM Borega ***@***.***> wrote: its seems ur not working with the version from the repo. Pls use that. it should work — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#9 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ATMNX5RSQOUJ577YOIVWBWTTFWTSXANCNFSM4Z4GTZOQ> .

[Tektic]

Config.Recipes.push([Recipe.Socket.Armor, "Sacred Armor", Roll.Eth]); // Socket ethereal Sacred Armor

This does not work with new cubing file. You have it cubing things for you besides pgems and runes??

[Borega]

amulets and rings work fine. others are untested

[Tektic]

Interesting. which rings work for you blood? nothing happens on my end with the new cubing.js file. do i need to update other files?

[Borega]

Caster Rings and Amu worked for me.

[mirage1111]

i'm getting a bit confused.
do i copy paste the entire thing into my cubing.js?
any links for a cubing.js file with these updates?
sorry, i just can't even get rings and ammys to cube, keeps throwing error on console once bot gathers all ingredients