pimi-launcher-core/components/launcher.js

171 lines
6.5 KiB
JavaScript
Raw Normal View History

2020-05-29 05:39:13 +03:00
const child = require('child_process')
const path = require('path')
const Handler = require('./handler')
const fs = require('fs')
const EventEmitter = require('events').EventEmitter
2018-10-30 01:13:58 +03:00
2019-05-23 01:28:48 +03:00
class MCLCore extends EventEmitter {
2020-06-19 19:26:58 +03:00
async launch (options) {
this.options = { ...options }
2020-05-29 05:39:13 +03:00
this.options.root = path.resolve(this.options.root)
this.options.overrides = {
2020-06-20 05:21:00 +03:00
detached: true,
2020-05-29 05:39:13 +03:00
...this.options.overrides,
url: {
meta: 'https://launchermeta.mojang.com',
resource: 'https://resources.download.minecraft.net',
mavenForge: 'http://files.minecraftforge.net/maven/',
defaultRepoForge: 'https://libraries.minecraft.net/',
fallbackMaven: 'https://search.maven.org/remotecontent?filepath=',
...this.options.overrides
? this.options.overrides.url
: undefined
}
2019-04-29 00:52:37 +03:00
}
2020-11-27 03:22:41 +03:00
this.options.fw = {
baseUrl: 'https://github.com/ZekerZhayard/ForgeWrapper/releases/download/',
version: '1.4.2',
sh1: '79ff9c1530e8743450c5c3ebc6e07b535437aa6e',
size: 22346
2020-05-29 05:39:13 +03:00
}
this.handler = new Handler(this)
this.printVersion()
2020-05-29 05:39:13 +03:00
const java = await this.handler.checkJava(this.options.javaPath || 'java')
if (!java.run) {
this.emit('debug', `[MCLC]: Couldn't start Minecraft due to: ${java.message}`)
this.emit('close', 1)
return null
}
this.createRootDirectory()
this.createGameDirectory()
2020-05-29 05:39:13 +03:00
await this.extractPackage()
2020-05-29 05:39:13 +03:00
if (this.options.installer) {
// So installers that create a profile in launcher_profiles.json can run without breaking.
2020-05-29 05:39:13 +03:00
const profilePath = path.join(this.options.root, 'launcher_profiles.json')
if (!fs.existsSync(profilePath)) { fs.writeFileSync(profilePath, JSON.stringify({}, null, 4)) }
await this.handler.runInstaller(this.options.installer)
}
const directory = this.options.overrides.directory || path.join(this.options.root, 'versions', this.options.version.custom ? this.options.version.custom : this.options.version.number)
2020-05-29 05:39:13 +03:00
this.options.directory = directory
const versionFile = await this.handler.getVersion()
const mcPath = this.options.overrides.minecraftJar || (this.options.version.custom
? path.join(this.options.root, 'versions', this.options.version.custom, `${this.options.version.custom}.jar`)
: path.join(directory, `${this.options.version.number}.jar`))
2020-11-27 03:22:41 +03:00
this.options.mcPath = mcPath
2020-05-29 05:39:13 +03:00
const nativePath = await this.handler.getNatives()
2018-10-30 01:13:58 +03:00
2020-05-29 05:39:13 +03:00
if (!fs.existsSync(mcPath)) {
this.emit('debug', '[MCLC]: Attempting to download Minecraft version jar')
await this.handler.getJar()
}
const modifyJson = await this.getModifyJson()
2020-05-29 05:39:13 +03:00
const args = []
let jvm = [
'-XX:-UseAdaptiveSizePolicy',
'-XX:-OmitStackTraceInFastThrow',
'-Dfml.ignorePatchDiscrepancies=true',
'-Dfml.ignoreInvalidMinecraftCertificates=true',
2020-06-19 19:26:58 +03:00
`-Djava.library.path=${nativePath}`,
2020-08-24 06:57:28 +03:00
`-Xmx${this.handler.getMemory()[0]}`,
`-Xms${this.handler.getMemory()[1]}`
2020-05-29 05:39:13 +03:00
]
if (this.handler.getOS() === 'osx') {
if (parseInt(versionFile.id.split('.')[1]) > 12) jvm.push(await this.handler.getJVM())
} else jvm.push(await this.handler.getJVM())
if (this.options.customArgs) jvm = jvm.concat(this.options.customArgs)
const classes = this.options.overrides.classes || this.handler.cleanUp(await this.handler.getClasses(modifyJson))
2020-05-29 05:39:13 +03:00
const classPaths = ['-cp']
const separator = this.handler.getOS() === 'windows' ? ';' : ':'
this.emit('debug', `[MCLC]: Using ${separator} to separate class paths`)
// Handling launch arguments.
const file = modifyJson || versionFile
// So mods like fabric work.
const jar = fs.existsSync(mcPath)
? `${separator}${mcPath}`
: `${separator}${path.join(directory, `${this.options.version.number}.jar`)}`
classPaths.push(`${this.options.forge ? this.options.forge + separator : ''}${classes.join(separator)}${jar}`)
classPaths.push(file.mainClass)
2020-05-29 05:39:13 +03:00
this.emit('debug', '[MCLC]: Attempting to download assets')
await this.handler.getAssets()
2020-07-08 06:36:31 +03:00
// Forge -> Custom -> Vanilla
const launchOptions = await this.handler.getLaunchOptions(modifyJson)
2020-05-29 05:39:13 +03:00
const launchArguments = args.concat(jvm, classPaths, launchOptions)
this.emit('arguments', launchArguments)
this.emit('debug', `[MCLC]: Launching with arguments ${launchArguments.join(' ')}`)
return this.startMinecraft(launchArguments)
}
printVersion () {
if (fs.existsSync(path.join(__dirname, '..', 'package.json'))) {
const { version } = require('../package.json')
this.emit('debug', `[MCLC]: MCLC version ${version}`)
} else { this.emit('debug', '[MCLC]: Package JSON not found, skipping MCLC version check.') }
}
createRootDirectory () {
if (!fs.existsSync(this.options.root)) {
this.emit('debug', '[MCLC]: Attempting to create root folder')
fs.mkdirSync(this.options.root)
}
}
createGameDirectory () {
if (this.options.overrides.gameDirectory) {
this.options.overrides.gameDirectory = path.resolve(this.options.overrides.gameDirectory)
if (!fs.existsSync(this.options.overrides.gameDirectory)) {
fs.mkdirSync(this.options.overrides.gameDirectory, { recursive: true })
}
}
}
async extractPackage () {
if (this.options.clientPackage) {
this.emit('debug', `[MCLC]: Extracting client package to ${this.options.root}`)
await this.handler.extractPackage()
}
}
async getModifyJson () {
let modifyJson = null
if (this.options.forge) {
this.options.forge = path.resolve(this.options.forge)
this.emit('debug', '[MCLC]: Detected Forge in options, getting dependencies')
modifyJson = await this.handler.getForgedWrapped()
} else if (this.options.version.custom) {
this.emit('debug', '[MCLC]: Detected custom in options, setting custom version file')
modifyJson = modifyJson || JSON.parse(fs.readFileSync(path.join(this.options.root, 'versions', this.options.version.custom, `${this.options.version.custom}.json`), { encoding: 'utf8' }))
}
return modifyJson
}
startMinecraft (launchArguments) {
2020-05-29 05:39:13 +03:00
const minecraft = child.spawn(this.options.javaPath ? this.options.javaPath : 'java', launchArguments,
2020-06-20 05:21:00 +03:00
{ cwd: this.options.overrides.cwd || this.options.root, detached: this.options.overrides.detached })
2020-05-29 05:39:13 +03:00
minecraft.stdout.on('data', (data) => this.emit('data', data.toString('utf-8')))
minecraft.stderr.on('data', (data) => this.emit('data', data.toString('utf-8')))
minecraft.on('close', (code) => this.emit('close', code))
return minecraft
}
2019-05-23 01:28:48 +03:00
}
2018-10-30 01:13:58 +03:00
2020-05-29 05:39:13 +03:00
module.exports = MCLCore