Funkin/project.hxp

package;

// I don't think we can import `funkin` classes here. Macros? Recursion? IDK.
import hxp.*;
import lime.tools.*;
import sys.FileSystem;

using StringTools;

/**
 * This HXP performs the functions of a Lime `project.xml` file,
 * but it's written in Haxe rather than XML!
 *
 * This makes it far easier to organize, reuse, and refactor,
 * and improves management of feature flag logic.
 */
@:nullSafety
class Project extends HXProject {
	//
	// METADATA
	//

	/**
	 * The game's version number, as a Semantic Versioning string with no prefix.
	 * REMEMBER TO CHANGE THIS WHEN THE GAME UPDATES!
	 * You only have to change it here, the rest of the game will query this value.
	 */
	static final VERSION:String = "0.5.0";

	/**
	 * The game's name. Used as the default window title.
	 */
	static final TITLE:String = "Friday Night Funkin'";

	/**
	 * The name of the generated executable file.
	 * For example, `"Funkin"` will create a file called `Funkin.exe`.
	 */
	static final EXECUTABLE_NAME:String = "Funkin";

	/**
	 * The relative location of the source code.
	 */
	static final SOURCE_DIR:String = "source";

	/**
	 * The fully qualified class path for the game's preloader.
	 * Particularly important on HTML5 but we use it on all platforms.
	 */
	static final PRELOADER:String = "funkin.ui.transition.preload.FunkinPreloader";

	/**
	 * A package name used for identifying the app on various app stores.
	 */
	static final PACKAGE_NAME:String = "me.funkin.fnf";

	/**
	 * The fully qualified class path for the entry point class to execute when launching the game.
	 * It's where `public static function main():Void` goes.
	 */
	static final MAIN_CLASS:String = "Main";

	/**
	 * The company name for the game.
	 * This appears in metadata in places I think.
	 */
	static final COMPANY:String = "The Funkin' Crew";

  /**
   * Path to the Haxe script run before building the game.
   */
  static final PREBUILD_HX:String = "source/Prebuild.hx";

  /**
   * Path to the Haxe script run after building the game.
   */
  static final POSTBUILD_HX:String = "source/Postbuild.hx";

	/**
	 * Asset path globs to always exclude from asset libraries.
	 */
	static final EXCLUDE_ASSETS:Array<String> = [".*", "cvs", "thumbs.db", "desktop.ini", "*.hash", "*.md"];

	/**
	 * Asset path globs to exclude on web platforms.
	 */
	static final EXCLUDE_ASSETS_WEB:Array<String> = ["*.ogg"];
	/**
	 * Asset path globs to exclude on native platforms.
	 */
	static final EXCLUDE_ASSETS_NATIVE:Array<String> = ["*.mp3"];

	//
	// FEATURE FLAGS
	// Inverse feature flags are automatically populated.
	//

	/**
	 * `-DGITHUB_BUILD`
	 * If this flag is enabled, the game will use the configuration used by GitHub Actions
	 * to generate playtest builds to be pushed to the launcher.
	 *
	 * This is generally used to forcibly enable debugging features,
	 * even when the game is built in release mode for performance reasons.
	 */
	static final GITHUB_BUILD:FeatureFlag = "GITHUB_BUILD";

	/**
	 * `-DREDIRECT_ASSETS_FOLDER`
	 * If this flag is enabled, the game will redirect the `assets` folder from the `export` folder
	 * to the `assets` folder at the root of the workspace.
	 * This is useful for ensuring hot reloaded changes don't get lost when rebuilding the game.
	 */
	static final REDIRECT_ASSETS_FOLDER:FeatureFlag = "REDIRECT_ASSETS_FOLDER";

	/**
	 * `-DTOUCH_HERE_TO_PLAY`
	 * If this flag is enabled, the game will display a prompt to the user after the preloader completes,
	 * requiring them to click anywhere on the screen to start the game.
	 * This is done to ensure that the audio context can initialize properly on HTML5. Not necessary on desktop.
	 */
	static final TOUCH_HERE_TO_PLAY:FeatureFlag = "TOUCH_HERE_TO_PLAY";

	/**
	 * `-DPRELOAD_ALL`
	 * Whether to preload all asset libraries.
	 * Disabled on web, enabled on desktop.
	 */
	static final PRELOAD_ALL:FeatureFlag = "PRELOAD_ALL";

	/**
	 * `-DEMBED_ASSETS`
	 * Whether to embed all asset libraries into the executable.
	 */
	static final EMBED_ASSETS:FeatureFlag = "EMBED_ASSETS";

  /**
   * `-DHARDCODED_CREDITS`
   * If this flag is enabled, the credits will be parsed and encoded in the game at compile time,
   * rather than read from JSON data at runtime.
   */
  static final HARDCODED_CREDITS:FeatureFlag = "HARDCODED_CREDITS";

	/**
	 * `-DFEATURE_DEBUG_FUNCTIONS`
	 * If this flag is enabled, the game will have all playtester-only debugging functionality enabled.
	 * This includes debug hotkeys like time travel in the Play State.
	 * By default, enabled on debug builds or playtester builds and disabled on release builds.
	 */
	static final FEATURE_DEBUG_FUNCTIONS:FeatureFlag = "FEATURE_DEBUG_FUNCTIONS";

	/**
	 * `-DFEATURE_DISCORD_RPC`
	 * If this flag is enabled, the game will enable the Discord Remote Procedure Call library.
	 * This is used to provide Discord Rich Presence support.
	 */
	static final FEATURE_DISCORD_RPC:FeatureFlag = "FEATURE_DISCORD_RPC";

	/**
	 * `-DFEATURE_NEWGROUNDS`
	 * If this flag is enabled, the game will enable the Newgrounds library.
	 * This is used to provide Medal and Leaderboard support.
	 */
	static final FEATURE_NEWGROUNDS:FeatureFlag = "FEATURE_NEWGROUNDS";

	/**
	 * `-DFEATURE_FUNKVIS`
	 * If this flag is enabled, the game will enable the Funkin Visualizer library.
	 * This is used to provide audio visualization like Nene's speaker.
	 * Disabling this will make some waveforms inactive.
	 */
	static final FEATURE_FUNKVIS:FeatureFlag = "FEATURE_FUNKVIS";

	/**
	 * `-DFEATURE_PARTIAL_SOUNDS`
	 * If this flag is enabled, the game will enable the FlxPartialSound library.
	 * This is used to provide audio previews in Freeplay.
	 * Disabling this will make those previews not play.
	 */
	static final FEATURE_PARTIAL_SOUNDS:FeatureFlag = "FEATURE_PARTIAL_SOUNDS";

	/**
	 * `-DFEATURE_VIDEO_PLAYBACK`
	 * If this flag is enabled, the game will enable support for video playback.
	 * This requires the hxCodec library on desktop platforms.
	 */
	static final FEATURE_VIDEO_PLAYBACK:FeatureFlag = "FEATURE_VIDEO_PLAYBACK";

  /**
	 * `-DFEATURE_FILE_DROP`
   * If this flag is enabled, the game will support dragging and dropping files onto it for various features.
   * Disabled on MacOS.
   */
  static final FEATURE_FILE_DROP:FeatureFlag = "FEATURE_FILE_DROP";

  /**
	 * `-DFEATURE_OPEN_URL`
   * If this flag is enabled, the game will support opening URLs (such as the merch page).
   */
  static final FEATURE_OPEN_URL:FeatureFlag = "FEATURE_OPEN_URL";

	/**
   * `-DFEATURE_CHART_EDITOR`
	 * If this flag is enabled, the Chart Editor will be accessible from the debug menu.
	 */
	static final FEATURE_CHART_EDITOR:FeatureFlag = "FEATURE_CHART_EDITOR";

	/**
	 * `-DFEATURE_STAGE_EDITOR`
   * If this flag is enabled, the Stage Editor will be accessible from the debug menu.
	 */
  static final FEATURE_STAGE_EDITOR:FeatureFlag = "FEATURE_STAGE_EDITOR";

	/**
	 * `-DFEATURE_POLYMOD_MODS`
	 * If this flag is enabled, the game will enable the Polymod library's support for atomic mod loading from the `./mods` folder.
	 * If this flag is disabled, no mods will be loaded.
	 */
	static final FEATURE_POLYMOD_MODS:FeatureFlag = "FEATURE_POLYMOD_MODS";

	/**
	 * `-DFEATURE_GHOST_TAPPING`
	 * If this flag is enabled, misses will not be counted when it is not the player's turn.
	 * Misses are still counted when the player has notes to hit.
	 */
	static final FEATURE_GHOST_TAPPING:FeatureFlag = "FEATURE_GHOST_TAPPING";

	//
	// CONFIGURATION FUNCTIONS
	//

	public function new() {
		super();

		flair();
		configureApp();

		displayTarget();
		configureFeatureFlags();
    configureCompileDefines();
		configureIncludeMacros();
		configureCustomMacros();
    configureOutputDir();
    configurePolymod();
    configureHaxelibs();
    configureAssets();
    configureIcons();
	}

	/**
	 * Do something before building, display some ASCII or something IDK
	 */
	function flair() {
		// TODO: Implement this.
		info("Friday Night Funkin'");
		info("Initializing build...");

		info("Target Version: " + VERSION);
		info("Git Branch:     " + getGitBranch());
		info("Git Commit:     " + getGitCommit());
		info("Git Modified?   " + getGitModified());
    info("Display?        " + isDisplay());
	}

	/**
	 * Apply basic project metadata, such as the game title and version number,
	 * as well as info like the package name and company (used by various app stores).
	 */
	function configureApp() {
		this.meta.title = TITLE;
		this.meta.version = VERSION;
		this.meta.packageName = PACKAGE_NAME;
		this.meta.company = COMPANY;

		this.app.main = MAIN_CLASS;
		this.app.file = EXECUTABLE_NAME;
		this.app.preloader = PRELOADER;

		// Tell Lime where to look for the game's source code.
		// If for some reason we have multiple source directories, we can add more entries here.
		this.sources.push(SOURCE_DIR);

    // Tell Lime to run some prebuild and postbuild scripts.
    this.preBuildCallbacks.push(buildHaxeCLICommand(PREBUILD_HX));
    this.postBuildCallbacks.push(buildHaxeCLICommand(POSTBUILD_HX));

		// TODO: Should we provide this?
		// this.meta.buildNumber = 0;

		// These values are only used by the SWF target I think.
		// this.app.path
		// this.app.init
		// this.app.swfVersion
		// this.app.url

		// These values are only used by... FIREFOX MARKETPLACE WHAT?
		// this.meta.description = "";
		// this.meta.companyId = COMPANY;
		// this.meta.companyUrl = COMPANY;

		// Configure the window.
		// Automatically configure FPS.
		this.window.fps = 60;
		// Set the window size.
		this.window.width = 1280;
		this.window.height = 720;
		// Black background on release builds, magenta on debug builds.
		this.window.background = FEATURE_DEBUG_FUNCTIONS.isEnabled(this) ? 0xFFFF00FF : 0xFF000000;

		this.window.hardware = true;
		this.window.vsync = false;

		if (isWeb()) {
			this.window.resizable = true;
		}

		if (isDesktop()) {
			this.window.orientation = Orientation.LANDSCAPE;
			this.window.fullscreen = false;
			this.window.resizable = true;
			this.window.vsync = false;
		}

		if (isMobile()) {
			this.window.orientation = Orientation.LANDSCAPE;
			this.window.fullscreen = false;
			this.window.resizable = false;
			this.window.width = 0;
			this.window.height = 0;
		}
	}

	/**
	 * Log information about the configured target platform.
	 */
	function displayTarget() {
		// Display the target operating system.
		switch (this.target) {
			case Platform.WINDOWS:
				info('Target Platform: Windows');
			case Platform.MAC:
				info('Target Platform: MacOS');
			case Platform.LINUX:
				info('Target Platform: Linux');
			case Platform.ANDROID:
				info('Target Platform: Android');
			case Platform.IOS:
				info('Target Platform: IOS');
			case Platform.HTML5:
				info('Target Platform: HTML5');
			// See lime.tools.Platform for a full list.
			// case Platform.EMSCRITEN: // A WebAssembly build might be interesting...
			// case Platform.AIR:
			// case Platform.BLACKBERRY:
			// case Platform.CONSOLE_PC:
			// case Platform.FIREFOX:
			// case Platform.FLASH:
			// case Platform.PS3:
			// case Platform.PS4:
			// case Platform.TIZEN:
			// case Platform.TVOS:
			// case Platform.VITA:
			// case Platform.WEBOS:
			// case Platform.WIIU:
			// case Platform.XBOX1:
			default:
				error('Unsupported platform (got ${target})');
		}

		switch (this.platformType) {
			case PlatformType.DESKTOP:
				info('Platform Type: Desktop');
			case PlatformType.MOBILE:
				info('Platform Type: Mobile');
			case PlatformType.WEB:
				info('Platform Type: Web');
			case PlatformType.CONSOLE:
				info('Platform Type: Console');
			default:
				error('Unknown platform type (got ${platformType})');
		}

    // Print whether we are using HXCPP, HashLink, or something else.
    if (isWeb()) {
      info('Target Language: JavaScript (HTML5)');
    } else if (isHashLink()) {
      info('Target Language: HashLink');
    } else if (isNeko()) {
      info('Target Language: Neko');
    } else if (isJava()) {
      info('Target Language: Java');
    } else if (isNodeJS()) {
      info('Target Language: JavaScript (NodeJS)');
    } else if (isCSharp()) {
      info('Target Language: C#');
    } else {
      info('Target Language: C++');
    }

		for (arch in this.architectures) {
			// Display the list of target architectures.
			switch (arch) {
				case Architecture.X86:
					info('Architecture: x86');
				case Architecture.X64:
					info('Architecture: x64');
				case Architecture.ARMV5:
					info('Architecture: ARMv5');
				case Architecture.ARMV6:
					info('Architecture: ARMv6');
				case Architecture.ARMV7:
					info('Architecture: ARMv7');
				case Architecture.ARMV7S:
					info('Architecture: ARMv7S');
				case Architecture.ARM64:
					info('Architecture: ARMx64');
				case Architecture.MIPS:
					info('Architecture: MIPS');
				case Architecture.MIPSEL:
					info('Architecture: MIPSEL');
				case null:
					if (!isWeb()) {
						error('Unsupported architecture (got null on non-web platform)');
					} else {
						info('Architecture: Web');
					}
				default:
					error('Unsupported architecture (got ${arch})');
			}
		}
	}

	/**
	 * Apply various feature flags based on the target platform and the user-provided build flags.
	 */
	function configureFeatureFlags() {
		// You can explicitly override any of these.
		// For example, `-DGITHUB_BUILD` or `-DNO_HARDCODED_CREDITS`

		// Should be false unless explicitly requested.
		GITHUB_BUILD.apply(this, false);
		FEATURE_STAGE_EDITOR.apply(this, false);
		FEATURE_NEWGROUNDS.apply(this, false);
		FEATURE_GHOST_TAPPING.apply(this, false);

		// Should be true unless explicitly requested.
		HARDCODED_CREDITS.apply(this, true);
		FEATURE_OPEN_URL.apply(this, true);
		FEATURE_POLYMOD_MODS.apply(this, true);
		FEATURE_FUNKVIS.apply(this, true);
		FEATURE_PARTIAL_SOUNDS.apply(this, true);
		FEATURE_VIDEO_PLAYBACK.apply(this, true);

		// Should be true on debug builds or if GITHUB_BUILD is enabled.
		FEATURE_DEBUG_FUNCTIONS.apply(this, isDebug() || GITHUB_BUILD.isEnabled(this));

		// Should default to true on workspace builds and false on release builds.
		REDIRECT_ASSETS_FOLDER.apply(this, isDebug() && isDesktop());

		// Should be true on release, non-tester builds.
		// We don't want testers to accidentally leak songs to their Discord friends!
    // TODO: Re-enable this.
		FEATURE_DISCORD_RPC.apply(this, false && !FEATURE_DEBUG_FUNCTIONS.isEnabled(this));

		// Should be true only on web builds.
		// Audio context issues only exist there.
		TOUCH_HERE_TO_PLAY.apply(this, isWeb());

		// Should be true only on web builds.
		// Enabling embedding and preloading is required to preload assets properly.
		EMBED_ASSETS.apply(this, isWeb());
		PRELOAD_ALL.apply(this, true);

		// Should be true except on MacOS.
		// File drop doesn't work there.
		FEATURE_FILE_DROP.apply(this, !isMac());

		// Should be true except on web builds.
		// Chart editor doesn't work there.
		FEATURE_CHART_EDITOR.apply(this, !isWeb());
	}

  /**
   * Set compilation flags which are not feature flags.
   */
  function configureCompileDefines() {
		// Enable OpenFL's error handler. Required for the crash logger.
    setHaxedef("openfl-enable-handle-error");

		// Enable stack trace tracking. Good for debugging but has a (minor) performance impact.
		setHaxedef("HXCPP_CHECK_POINTER");
		setHaxedef("HXCPP_STACK_LINE");
		setHaxedef("HXCPP_STACK_TRACE");
		setHaxedef("hscriptPos");

		setHaxedef("safeMode");

		// If we aren't using the Flixel debugger, strip it out.
		if (FEATURE_DEBUG_FUNCTIONS.isDisabled(this)) {
			setHaxedef("FLX_NO_DEBUG");
		}

		// Disable the built in pause screen when unfocusing the game.
		setHaxedef("FLX_NO_FOCUS_LOST_SCREEN");

		// HaxeUI configuration.
		setHaxedef("haxeui_no_mouse_reset");
		setHaxedef("haxeui_focus_out_on_click"); // Unfocus a dialog when clicking out of it
		setHaxedef("haxeui_dont_impose_base_class"); // Suppress a macro error

		if (isRelease()) {
			// Improve performance on Nape
			// TODO: Do we even use Nape?
			setHaxedef("NAPE_RELEASE_BUILD");
		}

		// Cleaner looking compiler errors.
		setHaxedef("message.reporting", "pretty");
  }

	/**
	 * Set compilation flags which manage dead code elimination.
	 */
	function configureIncludeMacros() {
		// Disable dead code elimination.
		// This prevents functions that are unused by the base game from being unavailable to HScript.
		addHaxeFlag("-dce no");

		// Forcibly include all Funkin' classes in builds.
		// This prevents classes that are unused by the base game from being unavailable to HScript.
		addHaxeMacro("include('funkin')");

		// Ensure all HaxeUI components are available at runtime.
		addHaxeMacro("include('haxe.ui.backend.flixel.components')");
		addHaxeMacro("include('haxe.ui.core')");
		addHaxeMacro("include('haxe.ui.components')");
		addHaxeMacro("include('haxe.ui.containers')");
		addHaxeMacro("include('haxe.ui.containers.dialogs')");
		addHaxeMacro("include('haxe.ui.containers.menus')");
		addHaxeMacro("include('haxe.ui.containers.properties')");

		// Ensure all Flixel classes are available at runtime.
		// Explicitly ignore packages which require additional dependencies.
		addHaxeMacro("include('flixel', true, [ 'flixel.addons.editors.spine.*', 'flixel.addons.nape.*', 'flixel.system.macros.*' ])");
	}

	/**
	 * Set compilation flags which manage bespoke build-time macros.
	 */
	function configureCustomMacros() {
		// This macro allows addition of new functionality to existing Flixel. -->
		addHaxeMacro("addMetadata('@:build(funkin.util.macro.FlxMacro.buildFlxBasic())', 'flixel.FlxBasic')");
	}

  function configureOutputDir() {
		// Set the output directory. Depends on the target platform and build type.

		var buildDir = 'export/${isDebug() ? 'debug' : 'release'}/';

		info('Output directory: $buildDir');
		// setenv('BUILD_DIR', buildDir);
		app.path = buildDir;
  }

  function configurePolymod() {
		// The file extension to use for script files.
		setHaxedef("POLYMOD_SCRIPT_EXT", ".hscript");
		// Which asset library to use for scripts.
		setHaxedef("POLYMOD_SCRIPT_LIBRARY", "scripts");
		// The base path from which scripts should be accessed.
		setHaxedef("POLYMOD_ROOT_PATH", "scripts/");
		// Determines the subdirectory of the mod folder used for file appending.
		setHaxedef("POLYMOD_APPEND_FOLDER", "_append");
		// Determines the subdirectory of the mod folder used for file merges.
		setHaxedef("POLYMOD_MERGE_FOLDER", "_merge");
		// Determines the file in the mod folder used for metadata.
		setHaxedef("POLYMOD_MOD_METADATA_FILE", "_polymod_meta.json");
		// Determines the file in the mod folder used for the icon.
		setHaxedef("POLYMOD_MOD_ICON_FILE", "_polymod_icon.png");

    if (isDebug()) {
		  // Turns on additional debug logging.
      setHaxedef("POLYMOD_DEBUG");
    }
  }

  function configureHaxelibs() {
		// Don't enforce
    addHaxelib('lime'); // Game engine backend
    addHaxelib('openfl'); // Game engine backend

    addHaxelib('flixel'); // Game engine

    addHaxelib('flixel-addons'); // Additional utilities for Flixel
    addHaxelib('hscript'); // Scripting
    // addHaxelib('flixel-ui'); // UI framework (DEPRECATED)
    addHaxelib('haxeui-core'); // UI framework
    addHaxelib('haxeui-flixel'); // Integrate HaxeUI with Flixel
    addHaxelib('flixel-text-input'); // Improved text field rendering for HaxeUI

    addHaxelib('polymod'); // Modding framework
    addHaxelib('flxanimate'); // Texture atlas rendering

		addHaxelib('json2object'); // JSON parsing
    addHaxelib('jsonpath'); // JSON parsing
    addHaxelib('jsonpatch'); // JSON parsing
		addHaxelib('thx.core'); // General utility library, "the lodash of Haxe"
		addHaxelib('thx.semver'); // Version string handling

		if (isDebug()) {
			addHaxelib('hxcpp-debug-server'); // VSCode debug support
		}

    if (isDesktop() && !isHashLink() && FEATURE_VIDEO_PLAYBACK.isEnabled(this)) {
      // hxCodec doesn't function on HashLink or non-desktop platforms
			// It's also unnecessary if video playback is disabled
      addHaxelib('hxCodec'); // Video playback
    }

		if (FEATURE_DISCORD_RPC.isEnabled(this)) {
			addHaxelib('discord_rpc'); // Discord API
		}

		if (FEATURE_NEWGROUNDS.isEnabled(this)) {
			addHaxelib('newgrounds'); // Newgrounds API
		}

		if (FEATURE_FUNKVIS.isEnabled(this)) {
			addHaxelib('funkin.vis'); // Audio visualization
      addHaxelib('grig.audio'); // Audio data utilities
		}

		if (FEATURE_PARTIAL_SOUNDS.isEnabled(this)) {
			addHaxelib('FlxPartialSound'); // Partial sound
		}
  }

  function configureAssets() {
		var exclude = EXCLUDE_ASSETS.concat(isWeb() ? EXCLUDE_ASSETS_WEB : EXCLUDE_ASSETS_NATIVE);
		var shouldPreload = PRELOAD_ALL.isEnabled(this);
		var shouldEmbed = EMBED_ASSETS.isEnabled(this);

		if (shouldEmbed) {
			info('Embedding assets into executable...');
		} else {
			info('Including assets alongside executable...');
		}

		// Default asset library
		var shouldPreloadDefault = true;
		addAssetLibrary("default", shouldEmbed, shouldPreloadDefault);
		addAssetPath("assets/preload", "assets", "default", ["*"], exclude, shouldEmbed);

		// Font assets
		var shouldEmbedFonts = true;
		addAssetPath("assets/fonts", null, "default", ["*"], exclude, shouldEmbedFonts);

		// Shared asset libraries
		addAssetLibrary("songs", shouldEmbed, shouldPreload);
		addAssetPath("assets/songs", "assets/songs", "songs", ["*"], exclude, shouldEmbed);
		addAssetLibrary("shared", shouldEmbed, shouldPreload);
		addAssetPath("assets/shared", "assets/shared", "shared", ["*"], exclude, shouldEmbed);
		if (FEATURE_VIDEO_PLAYBACK.isEnabled(this)) {
			var shouldEmbedVideos = false;
			addAssetLibrary("videos", shouldEmbedVideos, shouldPreload);
			addAssetPath("assets/videos", "assets/videos", "videos", ["*"], exclude, shouldEmbedVideos);
		}

		// Level asset libraries
		addAssetLibrary("tutorial", shouldEmbed, shouldPreload);
		addAssetPath("assets/tutorial", "assets/tutorial", "tutorial", ["*"], exclude, shouldEmbed);
		addAssetLibrary("week1", shouldEmbed, shouldPreload);
		addAssetPath("assets/week1", "assets/week1", "week1", ["*"], exclude, shouldEmbed);
		addAssetLibrary("week2", shouldEmbed, shouldPreload);
		addAssetPath("assets/week2", "assets/week2", "week2", ["*"], exclude, shouldEmbed);
		addAssetLibrary("week3", shouldEmbed, shouldPreload);
		addAssetPath("assets/week3", "assets/week3", "week3", ["*"], exclude, shouldEmbed);
		addAssetLibrary("week4", shouldEmbed, shouldPreload);
		addAssetPath("assets/week4", "assets/week4", "week4", ["*"], exclude, shouldEmbed);
		addAssetLibrary("week5", shouldEmbed, shouldPreload);
		addAssetPath("assets/week5", "assets/week5", "week5", ["*"], exclude, shouldEmbed);
		addAssetLibrary("week6", shouldEmbed, shouldPreload);
		addAssetPath("assets/week6", "assets/week6", "week6", ["*"], exclude, shouldEmbed);
		addAssetLibrary("week7", shouldEmbed, shouldPreload);
		addAssetPath("assets/week7", "assets/week7", "week7", ["*"], exclude, shouldEmbed);
		addAssetLibrary("weekend1", shouldEmbed, shouldPreload);
		addAssetPath("assets/weekend1", "assets/weekend1", "weekend1", ["*"], exclude, shouldEmbed);

		// Art asset library (where README and CHANGELOG pull from)
		var shouldEmbedArt = false;
		var shouldPreloadArt = false;
		addAssetLibrary("art", shouldEmbedArt, shouldPreloadArt);
		addAsset("art/readme.txt", "do NOT readme.txt", "art", shouldEmbedArt);
		addAsset("LICENSE.md", "LICENSE.md", "art", shouldEmbedArt);
		addAsset("CHANGELOG.md", "CHANGELOG.md", "art", shouldEmbedArt);
	}

  /**
   * Configure the application's favicon and executable icon.
   */
  function configureIcons() {
		addIcon("art/icon16.png", 16);
		addIcon("art/icon32.png", 32);
		addIcon("art/icon64.png", 64);
		addIcon("art/iconOG.png");
  }

	//
	// HELPER FUNCTIONS
	// Easy functions to make the code more readable.
	//

	public function isWeb():Bool {
		return this.platformType == PlatformType.WEB;
	}

	public function isMobile():Bool {
		return this.platformType == PlatformType.MOBILE;
	}

	public function isDesktop():Bool {
		return this.platformType == PlatformType.DESKTOP;
	}

	public function isConsole():Bool {
		return this.platformType == PlatformType.CONSOLE;
	}

	public function is32Bit():Bool {
		return this.architectures.contains(Architecture.X86);
	}

	public function is64Bit():Bool {
		return this.architectures.contains(Architecture.X64);
	}

	public function isWindows():Bool {
		return this.target == Platform.WINDOWS;
	}

	public function isMac():Bool {
		return this.target == Platform.MAC;
	}

	public function isLinux():Bool {
		return this.target == Platform.LINUX;
	}

	public function isAndroid():Bool {
		return this.target == Platform.ANDROID;
	}

	public function isIOS():Bool {
		return this.target == Platform.IOS;
	}

  public function isHashLink():Bool {
    return this.targetFlags.exists("hl");
  }

  public function isNeko():Bool {
    return this.targetFlags.exists("neko");
  }

  public function isJava():Bool {
    return this.targetFlags.exists("java");
  }

  public function isNodeJS():Bool {
    return this.targetFlags.exists("nodejs");
  }

  public function isCSharp():Bool {
    return this.targetFlags.exists("cs");
  }

  public function isDisplay():Bool {
    return this.command == "display";
  }

	public function isDebug():Bool {
		return this.debug;
	}

	public function isRelease():Bool {
		return !isDebug();
	}

  public function getHaxedef(name:String):Null<Dynamic> {
    return this.haxedefs.get(name);
  }

  public function setHaxedef(name:String, ?value:String):Void {
    if (value == null) value = "";

    this.haxedefs.set(name, value);
  }

  public function unsetHaxedef(name:String):Void {
    this.haxedefs.remove(name);
  }

	public function getDefine(name:String):Null<Dynamic> {
		return this.defines.get(name);
	}

	public function hasDefine(name:String):Bool {
		return this.defines.exists(name);
	}

	/**
	 * Add a library to the list of dependencies for the project.
	 * @param name The name of the library to add.
	 * @param version The version of the library to add. Optional.
	 */
	public function addHaxelib(name:String, version:String = ""):Void {
		this.haxelibs.push(new Haxelib(name, version));
	}

	/**
	 * Add a `haxeflag` to the project.
	 */
	public function addHaxeFlag(value:String):Void {
		this.haxeflags.push(value);
	}

	/**
	 * Call a Haxe build macro.
	 */
	public function addHaxeMacro(value:String):Void {
		addHaxeFlag('--macro ${value}');
	}

	/**
	 * Add an icon to the project.
	 * @param icon The path to the icon.
	 * @param size The size of the icon. Optional.
	 */
	public function addIcon(icon:String, ?size:Int):Void {
		this.icons.push(new Icon(icon, size));
	}

	/**
	 * Add an asset to the game build.
	 * @param path The path the asset is located at.
	 * @param rename The path the asset should be placed.
	 * @param library The asset library to add the asset to. `null` = "default"
	 * @param embed Whether to embed the asset in the executable.
	 */
	public function addAsset(path:String, ?rename:String, ?library:String, embed:Bool = false):Void {
		// path, rename, type, embed, setDefaults
		var asset = new Asset(path, rename, null, embed, true);
		@:nullSafety(Off)
		{
			asset.library = library ?? "default";
		}
		this.assets.push(asset);
	}

	/**
	 * Add an entire path of assets to the game build.
	 * @param path The path the assets are located at.
	 * @param rename The path the assets should be placed.
	 * @param library The asset library to add the assets to. `null` = "default"
	 * @param include An optional array to include specific asset names.
	 * @param exclude An optional array to exclude specific asset names.
	 * @param embed Whether to embed the assets in the executable.
	 */
	public function addAssetPath(path:String, ?rename:String, library:String, ?include:Array<String>, ?exclude:Array<String>, embed:Bool = false):Void {
		// Argument parsing.
		if (path == "") return;

		if (include == null) include = [];

		if (exclude == null) exclude = [];

		var targetPath = rename ?? path;
		if (targetPath != "") targetPath += "/";

		// Validate path.
		if (!sys.FileSystem.exists(path)) {
			error('Could not find asset path "${path}".');
		} else if (!sys.FileSystem.isDirectory(path)) {
			error('Could not parse asset path "${path}", expected a directory.');
		} else {
			// info('  Found asset path "${path}".');
		}

		for (file in sys.FileSystem.readDirectory(path)) {
			if (sys.FileSystem.isDirectory('${path}/${file}')) {
				// Attempt to recursively add all assets in the directory.
				if (this.filter(file, ["*"], exclude)) {
					addAssetPath('${path}/${file}', '${targetPath}${file}', library, include, exclude, embed);
				}
			} else {
				if (this.filter(file, include, exclude)) {
					addAsset('${path}/${file}', '${targetPath}${file}', library, embed);
				}
			}
		}
	}

	/**
	 * Add an asset library to the game build.
	 * @param name The name of the library.
	 * @param embed
	 * @param preload
	 */
	public function addAssetLibrary(name:String, embed:Bool = false, preload:Bool = false):Void {
		// sourcePath, name, type, embed, preload, generate, prefix
    var sourcePath = '';
		this.libraries.push(new Library(sourcePath, name, null, embed, preload, false, ""));
	}

	//
	// PROCESS FUNCTIONS
	//

  /**
   * A CLI command to run a command in the shell.
   */
  public function buildCLICommand(cmd:String):CLICommand {
    return CommandHelper.fromSingleString(cmd);
  }

  /**
   * A CLI command to run a Haxe script via `--interp`.
   */
  public function buildHaxeCLICommand(path:String):CLICommand {
    return CommandHelper.interpretHaxe(path);
  }

	public function getGitCommit():String {
		// Cannibalized from GitCommit.hx
		var process = new sys.io.Process('git', ['rev-parse', 'HEAD']);
		if (process.exitCode() != 0) {
			var message = process.stderr.readAll().toString();
			error('[ERROR] Could not determine current git commit; is this a proper Git repository?');
		}

		var commitHash:String = process.stdout.readLine();
		var commitHashSplice:String = commitHash.substr(0, 7);

		return commitHashSplice;
	}

	public function getGitBranch():String {
		// Cannibalized from GitCommit.hx
		var branchProcess = new sys.io.Process('git', ['rev-parse', '--abbrev-ref', 'HEAD']);

		if (branchProcess.exitCode() != 0) {
			var message = branchProcess.stderr.readAll().toString();
			error('Could not determine current git branch; is this a proper Git repository?');
		}

		var branchName:String = branchProcess.stdout.readLine();

		return branchName;
	}

	public function getGitModified():Bool {
		var branchProcess = new sys.io.Process('git', ['status', '--porcelain']);

		if (branchProcess.exitCode() != 0) {
			var message = branchProcess.stderr.readAll().toString();
			error('Could not determine current git status; is this a proper Git repository?');
		}

		var output:String = '';
		try {
			output = branchProcess.stdout.readLine();
		} catch (e) {
			if (e.message == 'Eof') {
				// Do nothing.
				// Eof = No output.
			} else {
				// Rethrow other exceptions.
				throw e;
			}
		}

		return output.length > 0;
	}

	//
	// LOGGING FUNCTIONS
	//

	/**
	 * Display an error message. This should stop the build process.
	 */
	public function error(message:String):Void {
		Log.error('${message}');
	}

	/**
	 * Display an info message. This should not interfere with the build process.
	 */
	public function info(message:String):Void {
		// CURSED: We have to disable info() log calls because of a bug.
		// https://github.com/haxelime/lime-vscode-extension/issues/88

		// Log.info('[INFO] ${message}');

		// trace(message);
		// Sys.println(message);
		// Sys.stdout().writeString(message);
		// Sys.stderr().writeString(message);
	}
}

/**
 * An object representing a feature flag, which can be enabled or disabled.
 * Includes features such as automatic generation of compile defines and inversion.
 */
abstract FeatureFlag(String) {
	static final INVERSE_PREFIX:String = "NO_";

	public function new(input:String) {
		this = input;
	}

	@:from
	public static function fromString(input:String):FeatureFlag {
		return new FeatureFlag(input);
	}

	/**
	 * Enable/disable a feature flag if it is unset, and handle the inverse flag.
	 * Doesn't override a feature flag that was set explicitly.
	 * @param enableByDefault Whether to enable this feature flag if it is unset.
	 */
	public function apply(project:Project, enableByDefault:Bool = false):Void {
		// TODO: Name this function better?

		if (isEnabled(project)) {
			// If this flag was already enabled, disable the inverse.
			project.info('Enabling feature flag ${this}');
			getInverse().disable(project, false);
		} else if (getInverse().isEnabled(project)) {
			// If the inverse flag was already enabled, disable this flag.
			project.info('Disabling feature flag ${this}');
			disable(project, false);
		} else {
			if (enableByDefault) {
				// Enable this flag if it was unset, and disable the inverse.
				project.info('Enabling feature flag ${this}');
				enable(project, true);
			} else {
				// Disable this flag if it was unset, and enable the inverse.
				project.info('Disabling feature flag ${this}');
				disable(project, true);
			}
		}
	}

	/**
	 * Enable this feature flag by setting the appropriate compile define.
	 *
	 * @param project The project to modify.
	 * @param andInverse Also disable the feature flag's inverse.
	 */
	public function enable(project:Project, andInverse:Bool = true) {
		project.setHaxedef(this, "");
		if (andInverse) {
			getInverse().disable(project, false);
		}
	}

	/**
	 * Disable this feature flag by removing the appropriate compile define.
	 *
	 * @param project The project to modify.
	 * @param andInverse Also enable the feature flag's inverse.
	 */
	public function disable(project:Project, andInverse:Bool = true) {
		project.unsetHaxedef(this);
		if (andInverse) {
			getInverse().enable(project, false);
		}
	}

	/**
	 * Query if this feature flag is enabled.
	 * @param project The project to query.
	 */
	public function isEnabled(project:Project):Bool {
		// Check both Haxedefs and Defines for this flag.
		return project.haxedefs.exists(this) || project.defines.exists(this);
	}

	/**
	 * Query if this feature flag's inverse is enabled.
	 */
	public function isDisabled(project:Project):Bool {
		return getInverse().isEnabled(project);
	}

	/**
	 * Return the inverse of this feature flag.
	 * @return A new feature flag that is the inverse of this one.
	 */
	public function getInverse():FeatureFlag {
		if (this.startsWith(INVERSE_PREFIX)) {
			return this.substring(INVERSE_PREFIX.length);
		}
		return INVERSE_PREFIX + this;
	}
}