default.dbj

// default.dbj gets executed upon gamejoin
js_strict(true);

include("json2.js");
include("NTItemParser.dbl");
include("OOG.js");
include("AutoMule.js");
include("Gambling.js");
include("CraftingSystem.js");
include("TorchSystem.js");
include("MuleLogger.js");
include("GameAction.js");
include("common/Attack.js");
include("common/Cubing.js");
include("common/CollMap.js");
include("common/Config.js");
include("common/Loader.js");
include("common/misc.js");
include("common/util.js");
include("common/Pickit.js");
include("common/Pather.js");
include("common/Precast.js");
include("common/Prototypes.js");
include("common/Runewords.js");
include("common/Storage.js");
include("common/Town.js");

function main () {
	D2Bot.init(); // Get D2Bot# handle
	D2Bot.ingame();

	// wait until game is ready
	while (!me.gameReady) {
		delay(50);
	}

	clearAllEvents(); // remove any event listeners from game crash

	if (!getScript("tools/heartbeat.js")) {
		load("tools/heartbeat.js");
	}

	// Include SoloPlay's librarys
	if (getScript("D2BotSoloPlay.dbj")) {
		include("SoloPlay/Tools/Developer.js");
		include("SoloPlay/Tools/Tracker.js");
		include("SoloPlay/Tools/CharData.js");
		include("SoloPlay/Functions/ConfigOverrides.js");
		include("SoloPlay/Functions/Globals.js");
		SetUp.include();
		Developer.logPerformance && Tracker.update();
	}

	if (getScript("d2botmap.dbj")) {
		load("tools/mapthread.js");
		FileTools.exists("tools/maptoolsthread.js") ? load("tools/maptoolsthread.js") : load("tools/ToolsThread.js");
		Config.init(true);
		LocalChat.init();

		Config.PublicMode && load("tools/party.js");
		Config.ManualPlayPick && load("tools/pickthread.js");
		Config.AutoMap && (me.automap = true);

		while (true) {
			delay(1000);
		}
	}
	
	if (getScript("D2BotShopDrop.dbj")) {
		return true;
	}
	
	// don't load default for dropper/mules
	if (getScript("D2BotDropper.dbj") || getScript("D2BotMule.dbj") || getScript("D2BotDrop.dbj")) {
		while(true) {
			try {
				if (me.gameReady && me.ingame && !me.inTown) {
					D2Bot.printToConsole("Saved from suicide walk!");
					D2Bot.restart();
				}
			} catch (e) {
				D2Bot.restart();
			}
			delay(1000);
		}
		return true;
	}

	// MuleLogger handler
	if (MuleLogger.inGameCheck()) {
		return true;
	}

	let i, sojPause, stats, anni,
		sojCounter = 0,
		startTime = getTickCount();

	this.itemEvent = function (gid, mode, code, global) {
		if (gid > 0 && mode === 0) {
			Pickit.gidList.push(gid);
		}
	};

	this.scriptEvent = function (msg) {
		switch (msg) {
		case "soj":
			sojPause = true;
			sojCounter = 0;

			break;
		}
	};

	this.copyDataEvent = function (mode, msg) {
		// "Mule Profile" option from D2Bot#
		if (mode === 0 && msg === "mule") {
			if (AutoMule.getInfo() && AutoMule.getInfo().hasOwnProperty("muleInfo")) {
				if (AutoMule.getMuleItems().length > 0) {
					D2Bot.printToConsole("Mule triggered");
					scriptBroadcast("mule");
					scriptBroadcast("quit");
				} else {
					D2Bot.printToConsole("No items to mule.");
				}
			} else {
				D2Bot.printToConsole("Profile not enabled for muling.");
			}
		}

		// getProfile
		if (mode === 1638) {
			msg = JSON.parse(msg);

			if (msg.Tag) {
				GameAction.init(msg.Tag);
			}
		}
	};

	// Initialize libs - load config variables, build pickit list, attacks, containers and cubing and runeword recipes
	Config.init(true);
	Pickit.init(true);
	Attack.init();
	Storage.Init();
	CraftingSystem.buildLists();
	Runewords.init();
	Cubing.init();
	LocalChat.init();

	// Load event listeners
	addEventListener("scriptmsg", this.scriptEvent);
	addEventListener("copydata", this.copyDataEvent);

	// GameAction/AutoMule/TorchSystem/Gambling/Crafting handler
	if (GameAction.inGameCheck() || AutoMule.inGameCheck() || TorchSystem.inGameCheck() || Gambling.inGameCheck() || CraftingSystem.inGameCheck()) {
		return true;
	}

	me.maxgametime = Config.MaxGameTime * 1000;
	stats = DataFile.getStats();

	// Check for experience decrease -> log death. Skip report if life chicken is disabled.
	if (stats.name === me.name && me.getStat(13) < stats.experience && Config.LifeChicken > 0) {
		D2Bot.printToConsole("You died in last game", 9);
		D2Bot.printToConsole("Experience decreased by " + (stats.experience - me.getStat(13)), 9);
		DataFile.updateStats("deaths");
		D2Bot.updateDeaths();
	}

	DataFile.updateStats(["experience", "name"]);

	// Load threads
	if (getScript("D2BotSoloPlay.dbj")) {
		if (SoloEvents.inGameCheck()) return true;
		load("libs/SoloPlay/Tools/ToolsThread.js");
		load("libs/SoloPlay/Tools/EventThread.js");
		load("libs/SoloPlay/Tools/TownChicken.js");
		// check in case we reloaded and guard was still running
		let guard = getScript("libs/SoloPlay/Modules/Guard.js");
		!!guard && guard.running && guard.stop();
		
		// Load guard if we want to see the stack as it runs
		if (Developer.debugging.showStack.enabled) {
			Developer.debugging.showStack.profiles.some(profile => profile.toLowerCase() === "all" || profile.toLowerCase() === me.profile.toLowerCase()) && (require('../SoloPlay/Modules/Guard'));
		}

	} else {
		load("tools/ToolsThread.js");
		Config.TownCheck || Config.TownHP || Config.TownMP && load("tools/TownChicken.js");
	}

	if (Config.PublicMode) {
		Config.PublicMode === true ? require('libs/modules/SimpleParty') : load("tools/Party.js");
	}

	Config.AntiHostile && load("tools/AntiHostile.js");

	if (Config.FastPick) {
		print("ÿc2Fast pickit active.");
		addEventListener("itemaction", this.itemEvent);
	}

	// One time maintenance - check cursor, get corpse, clear leftover items, pick items in case anything important was dropped
	if (!Scripts.UserAddon && !Scripts.Test) {
		let orgx = me.x, orgy = me.y;

		Cubing.cursorCheck();
		Town.getCorpse();
		Town.clearBelt();
		Config.ClearInvOnStart && Town.clearInventory();

		if (getDistance(me, orgx, orgy) > 3) {
			Pather.moveTo(orgx, orgx);
		}
		
		Pickit.pickItems();
	}

	me.automap = Config.AutoMap;

	// Next game = drop keys
	if (TorchSystem.keyCheck()) {
		scriptBroadcast("torch");
	}

	// Auto skill and stat
	if (Config.AutoSkill.Enabled && include("common/AutoSkill.js")) {
		AutoSkill.init(Config.AutoSkill.Build, Config.AutoSkill.Save);
	}

	if (Config.AutoStat.Enabled && include("common/AutoStat.js")) {
		AutoStat.init(Config.AutoStat.Build, Config.AutoStat.Save, Config.AutoStat.BlockChance, Config.AutoStat.UseBulk);
	}

	// offline
	if (!me.realm) {
		D2Bot.updateRuns();
	}

	// Go
	Loader.init();

	if (Config.MinGameTime && getTickCount() - startTime < Config.MinGameTime * 1000) {
		try {
			Town.goToTown();

			while (getTickCount() - startTime < Config.MinGameTime * 1000) {
				me.overhead("Stalling for " + Math.round(((startTime + (Config.MinGameTime * 1000)) - getTickCount()) / 1000) + " Seconds");
				delay(1000);
			}
		} catch (e1) {
			print(e1);
		}
	}

	DataFile.updateStats("gold");

	if (sojPause) {
		try {
			Town.goToTown();
			Town.doChores();

			me.maxgametime = 0;

			while (sojCounter < Config.SoJWaitTime) {
				me.overhead("Waiting for SoJ sales... " + (Config.SoJWaitTime - sojCounter) + " min");
				delay(6e4);

				sojCounter += 1;
			}
		} catch (e2) {
			print(e2);
		}
	}

	if (Config.LastMessage) {
		switch (typeof Config.LastMessage) {
		case "string":
			say(Config.LastMessage.replace("$nextgame", DataFile.getStats().nextGame, "i"));

			break;
		case "object":
			for (i = 0; i < Config.LastMessage.length; i += 1) {
				say(Config.LastMessage[i].replace("$nextgame", DataFile.getStats().nextGame, "i"));
			}

			break;
		}
	}

	if (AutoMule.muleCheck()) {
		scriptBroadcast("mule");
	}

	// Anni handler. Mule Anni if it's in unlocked space and profile is set to mule torch/anni.
	anni = me.findItem(603, 0, -1, 7);

	if (anni && !Storage.Inventory.IsLocked(anni, Config.Inventory) && AutoMule.getInfo() && AutoMule.getInfo().hasOwnProperty("torchMuleInfo")) {
		scriptBroadcast("muleAnni");
	}

	if (CraftingSystem.checkFullSets()) {
		scriptBroadcast("crafting");
	}

	if (TorchSystem.keyCheck()) {
		scriptBroadcast("torch");
	}

	scriptBroadcast("quit");

	return true;
}