Matan merge

app/assets/css/global.css

@@ -0,0 +1,55 @@
+
+@font-face {
+    font-family: ringbearer;
+    src: url('../fonts/ringbearer.ttf');
+}
+
+/* Logger font, found on https://fonts.google.com/specimen/Inconsolata?selection.family=Inconsolata */
+@font-face {
+    font-family: inconsolata;
+    src: url('../fonts/Inconsolata-Bold.ttf');
+}
+
+
+html , body{
+    background: url('../images/BrownWithWignette.jpg') no-repeat center center fixed;
+    background-size: cover;
+}
+
+
+a, a:hover 
+{
+     color: black; 
+     text-decoration:none; 
+     cursor:pointer;  
+}
+
+
+pre {border: 0; background-color: transparent;}
+
+
+
+input{
+    width: 100%;
+    padding-left: 3px;
+    border: none;
+    border-bottom: 3px solid #ECECEC;
+    font-size: 20px;
+    outline:none;
+}
+
+
+p, img, pre, span, label, h1 ,h2 ,h3 {
+    -webkit-touch-callout: none; 
+    -webkit-user-select: none; 
+    -khtml-user-select: none;
+    -moz-user-select: none; 
+    -ms-user-select: none; 
+    user-select: none; 
+
+    -webkit-user-drag: none;
+    -khtml-user-drag: none;
+    -moz-user-drag: none;
+    -o-user-drag: none;
+    user-drag: none;
+}

app/assets/css/header.css

@@ -0,0 +1,46 @@
+#header_container {
+    background-color: black;
+    padding: 5px;
+    font-size: 0px;
+    text-align: center;
+    border-bottom: thick solid #a02d2a;
+    border-bottom-width: 5px;
+    position: relative;
+}
+
+/* Div container for the seal image. */
+#header_seal_container {
+    position: absolute;
+}
+
+/* Div container for the header image. */
+#header_img_container {
+   display: inline-block;
+   margin: 0 auto;
+}
+
+/* Seal and header images. */
+#header_seal,
+#header_img {
+   height: 75px;
+   width: auto;
+   display: block;
+}
+
+/* Div container for the social buttons. */
+#header_social_container {
+   position: absolute;
+   bottom: 0px;
+   right: 0px;
+   margin-bottom: 5px;
+}
+
+/* Social buttons. */
+.header_social_img {
+    height: 25px;
+    width: auto;
+    display: inline-block;
+    cursor: pointer;
+    margin-right: 5px;
+}
+

app/assets/css/nav.css

@@ -0,0 +1,48 @@
+ul {
+    list-style-type: none;
+    margin: 0;
+    padding: 0;
+}
+
+li {
+    float: left;
+    display: block;
+    padding: 12px;
+    padding-top: 5px;
+    text-align: center;
+}
+
+
+li:hover {
+    background-color: #a02d2a;
+}
+
+a{
+    font-size: 20px;
+    font-family: 'ringbearer';
+}
+.player_icon{
+    margin-top: 120px;
+    margin-left: -15px;
+    width: 100%;
+}
+
+
+.input_text{
+    font-size: 20px;
+    font-family: 'bitter', italic;
+    color: black;
+    text-align: center;
+    padding-top: 40px;
+}
+
+.input{
+    width: 100%;
+    margin: 0 auto;
+    border: none;
+    border-bottom: 3px solid #bdc3c7;
+    outline: none;
+    font-size: 20px;
+    
+}
+

app/assets/css/styles.css

@@ -0,0 +1,121 @@
+/*******************************************************************************
+ *                                                                             *
+ * Fonts                                                                       *
+ *                                                                             *
+ ******************************************************************************/
+
+ /* Primary font for the application, found on http://www.dafont.com/ringbearer.font */ 
+@font-face {
+    font-family: ringbearer;
+    src: url('../fonts/ringbearer.ttf');
+}
+
+/* Logger font, found on https://fonts.google.com/specimen/Inconsolata?selection.family=Inconsolata */
+@font-face {
+    font-family: inconsolata;
+    src: url('../fonts/Inconsolata-Bold.ttf');
+}
+
+/*******************************************************************************
+ *                                                                             *
+ * Body                                                                        *
+ *                                                                             *
+ ******************************************************************************/
+
+/* Reset body, html, and div presets. */
+body, html, div {
+    margin: 0px;
+    padding: 0px;
+}
+
+html {
+    background: url('../images/BrownWithWignette.jpg') no-repeat center center fixed;
+    background-size: cover;
+}
+
+/*******************************************************************************
+ *                                                                             *
+ * Header                                                                      *
+ *                                                                             *
+ ******************************************************************************/
+
+/* Main div header container. */
+#header_container {
+    background-color: black;
+    padding: 5px;
+    font-size: 0px;
+    text-align: center;
+    border-bottom: thick solid #a02d2a;
+    border-bottom-width: 5px;
+    position: relative;
+}
+
+/* Div container for the seal image. */
+#header_seal_container {
+    position: absolute;
+}
+
+/* Div container for the header image. */
+#header_img_container {
+   display: inline-block;
+   margin: 0 auto;
+}
+
+/* Seal and header images. */
+#header_seal,
+#header_img {
+   height: 75px;
+   width: auto;
+   display: block;
+}
+
+/* Div container for the social buttons. */
+#header_social_container {
+   position: absolute;
+   bottom: 0px;
+   right: 0px;
+   margin-bottom: 5px;
+}
+
+/* Social buttons. */
+.header_social_img {
+    height: 25px;
+    width: auto;
+    display: inline-block;
+    cursor: pointer;
+    margin-right: 5px;
+}
+
+/*******************************************************************************
+ *                                                                             *
+ * Left Body Container                                                         *
+ *                                                                             *
+ ******************************************************************************/
+
+#body_left_container {
+    width: 25%;
+    display: inline-block;
+}
+
+/*******************************************************************************
+ *                                                                             *
+ * Right Body Container                                                        *
+ *                                                                             *
+ ******************************************************************************/
+
+#body_right_container {
+    width: 75%;
+    display: inline-block;
+}
+
+.mtoggle_button {
+    text-align:centre; 
+    margin:5px 2px;
+    padding:0.4em 3em; 
+    color:#000; 
+    background-color:#FFF; 
+    border-radius:10px; 
+    display:inline-block; 
+    border:solid 1px #CCC; 
+    cursor:pointer;
+}

app/assets/js/assetdownload.js

@@ -0,0 +1,239 @@
+const fs = require('fs')
+const request = require('request')
+const path = require('path')
+const mkpath = require('mkdirp');
+const async = require('async')
+const crypto = require('crypto')
+const Library = require('./library.js')
+const {BrowserWindow} = require('electron')
+
+/**
+ * PHASING THIS OUT, WILL BE REMOVED WHEN ASSET GUARD MODULE IS COMPLETE!
+ */
+
+function Asset(from, to, size, hash){
+    this.from = from
+    this.to = to
+    this.size = size
+    this.hash = hash
+}
+
+function AssetIndex(id, sha1, size, url, totalSize){
+    this.id = id
+    this.sha1 = sha1
+    this.size = size
+    this.url = url
+    this.totalSize = totalSize
+}
+
+/**
+ * This function will download the version index data and read it into a Javascript
+ * Object. This object will then be returned.
+ */
+parseVersionData = function(version, basePath){
+    const name = version + '.json'
+    const baseURL = 'https://s3.amazonaws.com/Minecraft.Download/versions/' + version + '/' + name
+    const versionPath = path.join(basePath, 'versions', version)
+    
+    return new Promise(function(fulfill, reject){
+        request.head(baseURL, function(err, res, body){
+            console.log('Preparing download of ' + version + ' assets.')
+            mkpath.sync(versionPath)
+            const stream = request(baseURL).pipe(fs.createWriteStream(path.join(versionPath, name)))
+            stream.on('finish', function(){
+                fulfill(JSON.parse(fs.readFileSync(path.join(versionPath, name))))
+            })
+        })
+    })
+}
+
+/**
+ * Download the client for version. This file is 'client.jar' although
+ * it must be renamed to '{version}'.jar.
+ */
+downloadClient = function(versionData, basePath){
+    const dls = versionData['downloads']
+    const clientData = dls['client']
+    const url = clientData['url']
+    const size = clientData['size']
+    const version = versionData['id']
+    const sha1 = clientData['sha1']
+    const targetPath = path.join(basePath, 'versions', version)
+    const targetFile = version + '.jar'
+
+    if(!validateLocalIntegrity(path.join(targetPath, targetFile), 'sha1', sha1)){
+        request.head(url, function(err, res, body){
+            console.log('Downloading ' + version + ' client..')
+            mkpath.sync(targetPath)
+            const stream = request(url).pipe(fs.createWriteStream(path.join(targetPath, targetFile)))
+            stream.on('finish', function(){
+                console.log('Finished downloading ' + version + ' client.')
+            })
+        })
+    }
+}
+
+downloadLogConfig = function(versionData, basePath){
+    const logging = versionData['logging']
+    const client = logging['client']
+    const file = client['file']
+    const version = versionData['id']
+    const sha1 = file['sha1']
+    const targetPath = path.join(basePath, 'assets', 'log_configs')
+    const name = file['id']
+    const url = file['url']
+
+    if(!validateLocalIntegrity(path.join(targetPath, name), 'sha1', sha1)){
+        request.head(url, function(err, res, body){
+            console.log('Downloading ' + version + ' log config..')
+            mkpath.sync(targetPath)
+            const stream = request(url).pipe(fs.createWriteStream(path.join(targetPath, name)))
+            stream.on('finish', function(){
+                console.log('Finished downloading ' + version + ' log config..')
+            })
+        })
+    }
+}
+
+downloadLibraries = function(versionData, basePath){
+    const libArr = versionData['libraries']
+    const libPath = path.join(basePath, 'libraries')
+
+    let win = BrowserWindow.getFocusedWindow()
+    const libDlQueue = []
+    let dlSize = 0
+
+    //Check validity of each library. If the hashs don't match, download the library.
+    libArr.forEach(function(lib, index){
+        if(Library.validateRules(lib.rules)){
+            let artifact = null
+            if(lib.natives == null){
+                artifact = lib.downloads.artifact
+            } else {
+                artifact = lib.downloads.classifiers[lib.natives[Library.mojangFriendlyOS()]]
+            }
+            const libItm = new Library(lib.name, artifact.sha1, artifact.size, artifact.url, path.join(libPath, artifact.path))
+            if(!validateLocalIntegrity(libItm.to, 'sha1', libItm.sha1)){
+                dlSize += libItm.size
+                libDlQueue.push(libItm)
+            }
+        }
+    })
+
+    let acc = 0;
+
+    //Download all libraries that failed validation.
+    async.eachLimit(libDlQueue, 1, function(lib, cb){
+        mkpath.sync(path.join(lib.to, '..'))
+        let req = request(lib.from)
+        let writeStream = fs.createWriteStream(lib.to)
+        req.pipe(writeStream)
+
+        req.on('data', function(chunk){
+            acc += chunk.length
+            //console.log('Progress', acc/dlSize)
+            win.setProgressBar(acc/dlSize)
+        })
+        writeStream.on('close', cb)
+    }, function(err){
+        if(err){
+            console.log('A library failed to process');
+        } else {
+            console.log('All libraries have been processed successfully');
+        }
+        win.setProgressBar(-1)
+    })
+}
+
+/**
+ * Given an index url, this function will asynchonously download the
+ * assets associated with that version.
+ */
+downloadAssets = function(versionData, basePath){
+    //Asset index constants.
+    const assetIndex = versionData.assetIndex
+    const indexURL = assetIndex.url
+    const gameVersion = versionData.id
+    const assetVersion = assetIndex.id
+    const name = assetVersion + '.json'
+
+    //Asset constants
+    const resourceURL = 'http://resources.download.minecraft.net/'
+    const localPath = path.join(basePath, 'assets')
+    const indexPath = path.join(localPath, 'indexes')
+    const objectPath = path.join(localPath, 'objects')
+    
+    let win = BrowserWindow.getFocusedWindow()
+
+    const assetIndexLoc = path.join(indexPath, name)
+    /*if(!fs.existsSync(assetIndexLoc)){
+
+    }*/
+    console.log('Downloading ' + gameVersion + ' asset index.')
+    mkpath.sync(indexPath)
+    const stream = request(indexURL).pipe(fs.createWriteStream(assetIndexLoc))
+    stream.on('finish', function() {
+        const data = JSON.parse(fs.readFileSync(assetIndexLoc, 'utf-8'))
+        const assetDlQueue = []
+        let dlSize = 0;
+        Object.keys(data.objects).forEach(function(key, index){
+            const ob = data.objects[key]
+            const hash = ob.hash
+            const assetName = path.join(hash.substring(0, 2), hash)
+            const urlName = hash.substring(0, 2) + "/" + hash
+            const ast = new Asset(resourceURL + urlName, path.join(objectPath, assetName), ob.size, String(ob.hash))
+            if(!validateLocalIntegrity(ast.to, 'sha1', ast.hash)){
+                dlSize += ast.size
+                assetDlQueue.push(ast)
+            }
+        })
+
+        let acc = 0;
+        async.eachLimit(assetDlQueue, 5, function(asset, cb){
+            mkpath.sync(path.join(asset.to, ".."))
+            let req = request(asset.from)
+            let writeStream = fs.createWriteStream(asset.to)
+            req.pipe(writeStream)
+            req.on('data', function(chunk){
+                acc += chunk.length
+                console.log('Progress', acc/dlSize)
+                win.setProgressBar(acc/dlSize)
+            })
+            writeStream.on('close', cb)
+        }, function(err){
+            if(err){
+                console.log('An asset failed to process');
+            } else {
+                console.log('All assets have been processed successfully');
+            }
+            win.setProgressBar(-1)
+        })
+    })
+}
+
+validateLocalIntegrity = function(filePath, algo, hash){
+    if(fs.existsSync(filePath)){
+        let fileName = path.basename(filePath)
+        console.log('Validating integrity of local file', fileName)
+        let shasum = crypto.createHash(algo)
+        let content = fs.readFileSync(filePath)
+        shasum.update(content)
+        let localhash = shasum.digest('hex')
+        if(localhash === hash){
+            console.log('Hash value of ' + fileName + ' matches the index hash, woo!')
+            return true
+        } else {
+            console.log('Hash value of ' + fileName + ' (' + localhash + ')' + ' does not match the index hash. Redownloading..')
+            return false
+        }
+    }
+    return false;
+}
+
+module.exports = {
+    parseVersionData,
+    downloadClient,
+    downloadLogConfig,
+    downloadLibraries,
+    downloadAssets
+}

app/assets/js/assetguard.js

@@ -0,0 +1,587 @@
+/**
+ * AssetGuard
+ * 
+ * This module aims to provide a comprehensive and stable method for processing
+ * and downloading game assets for the WesterosCraft server. A central object
+ * stores download meta for several identifiers (categories). This meta data
+ * is initially empty until one of the module's processing functions are called.
+ * That function will process the corresponding asset index and validate any exisitng
+ * local files. If a file is missing or fails validation, it will be placed into an
+ * array which acts as a queue. This queue is wrapped in a download tracker object
+ * so that essential information can be cached. The download tracker object is then
+ * assigned as the value of the identifier in the central object. These download
+ * trackers will remain idle until an async process is started to process them.
+ * 
+ * Once the async process is started, any enqueued assets will be downloaded. The central
+ * object will emit events throughout the download whose name correspond to the identifier
+ * being processed. For example, if the 'assets' identifier was being processed, whenever
+ * the download stream recieves data, the event 'assetsdlprogress' will be emitted off of
+ * the central object instance. This can be listened to by external modules allowing for
+ * categorical tracking of the downloading process.
+ * 
+ * @module assetguard
+ */
+// Requirements
+const fs = require('fs')
+const request = require('request')
+const path = require('path')
+const mkpath = require('mkdirp');
+const async = require('async')
+const crypto = require('crypto')
+const AdmZip = require('adm-zip')
+const EventEmitter = require('events');
+const {remote} = require('electron')
+
+// Classes
+
+/** Class representing a base asset. */
+class Asset{
+    /**
+     * Create an asset.
+     * 
+     * @param {any} id - id of the asset.
+     * @param {String} hash - hash value of the asset.
+     * @param {Number} size - size in bytes of the asset.
+     * @param {String} from - url where the asset can be found.
+     * @param {String} to - absolute local file path of the asset.
+     */
+    constructor(id, hash, size, from, to){
+        this.id = id
+        this.hash = hash
+        this.size = size
+        this.from = from
+        this.to = to
+    }
+}
+
+/** Class representing a mojang library. */
+class Library extends Asset{
+
+    /**
+     * Converts the process.platform OS names to match mojang's OS names.
+     */
+    static mojangFriendlyOS(){
+        const opSys = process.platform
+        if (opSys === 'darwin') {
+            return 'osx';
+        } else if (opSys === 'win32'){
+            return 'windows';
+        } else if (opSys === 'linux'){
+            return 'linux';
+        } else {
+            return 'unknown_os';
+        }
+    }
+
+    /**
+     * Checks whether or not a library is valid for download on a particular OS, following
+     * the rule format specified in the mojang version data index. If the allow property has
+     * an OS specified, then the library can ONLY be downloaded on that OS. If the disallow
+     * property has instead specified an OS, the library can be downloaded on any OS EXCLUDING
+     * the one specified.
+     * 
+     * @param {Object} rules - the Library's download rules.
+     * @returns {Boolean} - true if the Library follows the specified rules, otherwise false.
+     */
+    static validateRules(rules){
+        if(rules == null) return true
+
+        let result = true
+        rules.forEach(function(rule){
+            const action = rule['action']
+            const osProp = rule['os']
+            if(action != null){
+                if(osProp != null){
+                    const osName = osProp['name']
+                    const osMoj = Library.mojangFriendlyOS()
+                    if(action === 'allow'){
+                        result = osName === osMoj
+                        return
+                    } else if(action === 'disallow'){
+                        result = osName !== osMoj
+                        return
+                    }
+                }
+            }
+        })
+        return result
+    }
+}
+
+/**
+ * Class representing a download tracker. This is used to store meta data
+ * about a download queue, including the queue itself.
+ */
+class DLTracker {
+    /**
+     * Create a DLTracker
+     * 
+     * @param {Array.<Asset>} dlqueue - an array containing assets queued for download.
+     * @param {Number} dlsize - the combined size of each asset in the download queue array.
+     */
+    constructor(dlqueue, dlsize){
+        this.dlqueue = dlqueue
+        this.dlsize = dlsize
+    }
+}
+
+/**
+ * Central object class used for control flow. This object stores data about
+ * categories of downloads. Each category is assigned an identifier with a 
+ * DLTracker object as its value. Combined information is also stored, such as
+ * the total size of all the queued files in each category. This event is used
+ * to emit events so that external modules can listen into processing done in
+ * this module.
+ */
+class AssetGuard extends EventEmitter{
+    /**
+     * AssetGuard class should only ever have one instance which is defined in
+     * this module. On creation the object's properties are never-null default
+     * values. Each identifier is resolved to an empty DLTracker.
+     */
+    constructor(){
+        super()
+        this.totaldlsize = 0;
+        this.progress = 0;
+        this.assets = new DLTracker([], 0)
+        this.libraries = new DLTracker([], 0)
+        this.files = new DLTracker([], 0)
+    }
+}
+
+/**
+ * Global static final instance of AssetGuard
+ */
+const instance = new AssetGuard()
+
+// Utility Functions
+
+/**
+ * Calculates the hash for a file using the specified algorithm.
+ * 
+ * @param {Buffer} buf - the buffer containing file data.
+ * @param {String} algo - the hash algorithm.
+ * @returns {String} - the calculated hash in hex.
+ */
+function _calculateHash(buf, algo){
+    return crypto.createHash(algo).update(buf).digest('hex')
+}
+
+/**
+ * Used to parse a checksums file. This is specifically designed for
+ * the checksums.sha1 files found inside the forge scala dependencies.
+ * 
+ * @param {String} content - the string content of the checksums file.
+ * @returns {Object} - an object with keys being the file names, and values being the hashes.
+ */
+function _parseChecksumsFile(content){
+    let finalContent = {}
+    let lines = content.split('\n')
+    for(let i=0; i<lines.length; i++){
+        let bits = lines[i].split(' ')
+        if(bits[1] == null) {
+            continue
+        }
+        finalContent[bits[1]] = bits[0]
+    }
+    return finalContent
+}
+
+/**
+ * Validate that a file exists and matches a given hash value.
+ * 
+ * @param {String} filePath - the path of the file to validate.
+ * @param {String} algo - the hash algorithm to check against.
+ * @param {String} hash - the existing hash to check against.
+ * @returns {Boolean} - true if the file exists and calculated hash matches the given hash, otherwise false.
+ */
+function _validateLocal(filePath, algo, hash){
+    if(fs.existsSync(filePath)){
+        let fileName = path.basename(filePath)
+        let buf = fs.readFileSync(filePath)
+        let calcdhash = _calculateHash(buf, algo)
+        return calcdhash === hash
+    }
+    return false;
+}
+
+/**
+ * Validates a file in the style used by forge's version index.
+ * 
+ * @param {String} filePath - the path of the file to validate.
+ * @param {Array.<String>} checksums - the checksums listed in the forge version index.
+ * @returns {Boolean} - true if the file exists and the hashes match, otherwise false.
+ */
+function _validateForgeChecksum(filePath, checksums){
+    if(fs.existsSync(filePath)){
+        if(checksums == null || checksums.length === 0){
+            return true
+        }
+        let buf = fs.readFileSync(filePath)
+        let calcdhash = _calculateHash(buf, 'sha1')
+        let valid = checksums.includes(calcdhash)
+        if(!valid && filePath.endsWith('.jar')){
+            valid = _validateForgeJar(filePath, checksums)
+        }
+        return valid
+    }
+    return false
+}
+
+/**
+ * Validates a forge jar file dependency who declares a checksums.sha1 file.
+ * This can be an expensive task as it usually requires that we calculate thousands
+ * of hashes.
+ * 
+ * @param {Buffer} buf - the buffer of the jar file.
+ * @param {Array.<String>} checksums - the checksums listed in the forge version index.
+ * @returns {Boolean} - true if all hashes declared in the checksums.sha1 file match the actual hashes.
+ */
+function _validateForgeJar(buf, checksums){
+    
+    const hashes = {}
+    let expected = {}
+
+    const zip = new AdmZip(buf)
+    const zipEntries = zip.getEntries()
+
+    //First pass
+    for(let i=0; i<zipEntries.length; i++){
+        let entry = zipEntries[i]
+        if(entry.entryName === 'checksums.sha1'){
+            expected = _parseChecksumsFile(zip.readAsText(entry))
+        }
+        hashes[entry.entryName] = _calculateHash(entry.getData(), 'sha1')
+    }
+
+    if(!checksums.includes(hashes['checksums.sha1'])){
+        return false
+    }
+
+    //Check against expected
+    const expectedEntries = Object.keys(expected)
+    for(let i=0; i<expectedEntries.length; i++){
+        if(expected[expectedEntries[i]] !== hashes[expectedEntries[i]]){
+            return false
+        }
+    }
+    return true
+}
+
+/**
+ * Initiate an async download process for an AssetGuard DLTracker.
+ * 
+ * @param {String} identifier - the identifier of the AssetGuard DLTracker.
+ * @param {Number} limit - optional. The number of async processes to run in parallel.
+ * @returns {Boolean} - true if the process began, otherwise false.
+ */
+function startAsyncProcess(identifier, limit = 5){
+    let win = remote.getCurrentWindow()
+
+    let acc = 0
+    const concurrentDlQueue = instance[identifier].dlqueue.slice(0)
+    if(concurrentDlQueue.length === 0){
+        return false
+    } else {
+        async.eachLimit(concurrentDlQueue, limit, function(asset, cb){
+            mkpath.sync(path.join(asset.to, ".."))
+            let req = request(asset.from)
+            let writeStream = fs.createWriteStream(asset.to)
+            req.pipe(writeStream)
+            req.on('data', function(chunk){
+                instance.progress += chunk.length
+                acc += chunk.length
+                instance.emit(identifier + 'dlprogress', acc)
+                //console.log(identifier + ' Progress', acc/instance[identifier].dlsize)
+                win.setProgressBar(instance.progress/instance.totaldlsize)
+            })
+            writeStream.on('close', cb)
+        }, function(err){
+            if(err){
+                instance.emit(identifier + 'dlerror')
+                console.log('An item in ' + identifier + ' failed to process');
+            } else {
+                instance.emit(identifier + 'dlcomplete')
+                console.log('All ' + identifier + ' have been processed successfully')
+            }
+            instance.totaldlsize -= instance[identifier].dlsize
+            instance[identifier] = new DLTracker([], 0)
+            if(instance.totaldlsize === 0) {
+                win.setProgressBar(-1)
+                instance.emit('dlcomplete')
+            }
+        })
+        return true
+    }
+}
+
+// Validation Functions
+
+/**
+ * Loads the version data for a given minecraft version.
+ * 
+ * @param {String} version - the game version for which to load the index data.
+ * @param {String} basePath - the absolute file path which will be prepended to the given relative paths.
+ * @param {Boolean} force - optional. If true, the version index will be downloaded even if it exists locally. Defaults to false.
+ * @returns {Promise.<Object>} - Promise which resolves to the version data object.
+ */
+function loadVersionData(version, basePath, force = false){
+    return new Promise(function(fulfill, reject){
+        const name = version + '.json'
+        const url = 'https://s3.amazonaws.com/Minecraft.Download/versions/' + version + '/' + name
+        const versionPath = path.join(basePath, 'versions', version)
+        const versionFile = path.join(versionPath, name)
+        if(!fs.existsSync(versionFile) || force){
+            //This download will never be tracked as it's essential and trivial.
+            request.head(url, function(err, res, body){
+                console.log('Preparing download of ' + version + ' assets.')
+                mkpath.sync(versionPath)
+                const stream = request(url).pipe(fs.createWriteStream(versionFile))
+                stream.on('finish', function(){
+                    fulfill(JSON.parse(fs.readFileSync(versionFile)))
+                })
+            })
+        } else {
+            fulfill(JSON.parse(fs.readFileSync(versionFile)))
+        }
+    })
+}
+
+/**
+ * Public asset validation function. This function will handle the validation of assets.
+ * It will parse the asset index specified in the version data, analyzing each
+ * asset entry. In this analysis it will check to see if the local file exists and is valid.
+ * If not, it will be added to the download queue for the 'assets' identifier.
+ * 
+ * @param {Object} versionData - the version data for the assets.
+ * @param {String} basePath - the absolute file path which will be prepended to the given relative paths.
+ * @param {Boolean} force - optional. If true, the asset index will be downloaded even if it exists locally. Defaults to false.
+ * @returns {Promise.<Void>} - An empty promise to indicate the async processing has completed.
+ */
+function validateAssets(versionData, basePath, force = false){
+    return new Promise(function(fulfill, reject){
+        _assetChainIndexData(versionData, basePath, force).then(() => {
+            fulfill()
+        })
+    })
+}
+
+//Chain the asset tasks to provide full async. The below functions are private.
+/**
+ * Private function used to chain the asset validation process. This function retrieves
+ * the index data.
+ * @param {Object} versionData
+ * @param {String} basePath
+ * @param {Boolean} force
+ * @returns {Promise.<Void>} - An empty promise to indicate the async processing has completed.
+ */
+function _assetChainIndexData(versionData, basePath, force = false){
+    return new Promise(function(fulfill, reject){
+        //Asset index constants.
+        const assetIndex = versionData.assetIndex
+        const name = assetIndex.id + '.json'
+        const indexPath = path.join(basePath, 'assets', 'indexes')
+        const assetIndexLoc = path.join(indexPath, name)
+
+        let data = null
+        if(!fs.existsSync(assetIndexLoc) || force){
+            console.log('Downloading ' + versionData.id + ' asset index.')
+            mkpath.sync(indexPath)
+            const stream = request(assetIndex.url).pipe(fs.createWriteStream(assetIndexLoc))
+            stream.on('finish', function() {
+                data = JSON.parse(fs.readFileSync(assetIndexLoc, 'utf-8'))
+                _assetChainValidateAssets(versionData, basePath, data).then(() => {
+                    fulfill()
+                })
+            })
+        } else {
+            data = JSON.parse(fs.readFileSync(assetIndexLoc, 'utf-8'))
+            _assetChainValidateAssets(versionData, basePath, data).then(() => {
+                fulfill()
+            })
+        }
+    })
+}
+
+/**
+ * Private function used to chain the asset validation process. This function processes
+ * the assets and enqueues missing or invalid files.
+ * @param {Object} versionData
+ * @param {String} basePath
+ * @param {Boolean} force
+ * @returns {Promise.<Void>} - An empty promise to indicate the async processing has completed.
+ */
+function _assetChainValidateAssets(versionData, basePath, indexData){
+    return new Promise(function(fulfill, reject){
+
+        //Asset constants
+        const resourceURL = 'http://resources.download.minecraft.net/'
+        const localPath = path.join(basePath, 'assets')
+        const indexPath = path.join(localPath, 'indexes')
+        const objectPath = path.join(localPath, 'objects')
+
+        const assetDlQueue = []
+        let dlSize = 0;
+        //const objKeys = Object.keys(data.objects)
+        async.forEachOfLimit(indexData.objects, 10, function(value, key, cb){
+            const hash = value.hash
+            const assetName = path.join(hash.substring(0, 2), hash)
+            const urlName = hash.substring(0, 2) + "/" + hash
+            const ast = new Asset(key, hash, String(value.size), resourceURL + urlName, path.join(objectPath, assetName))
+            if(!_validateLocal(ast.to, 'sha1', ast.hash)){
+                dlSize += (ast.size*1)
+                assetDlQueue.push(ast)
+            }
+            cb()
+        }, function(err){
+            instance.assets = new DLTracker(assetDlQueue, dlSize)
+            instance.totaldlsize += dlSize
+            fulfill()
+        })
+    })
+}
+
+/**
+ * Public library validation function. This function will handle the validation of libraries.
+ * It will parse the version data, analyzing each library entry. In this analysis, it will
+ * check to see if the local file exists and is valid. If not, it will be added to the download
+ * queue for the 'libraries' identifier.
+ * 
+ * @param {Object} versionData - the version data for the assets.
+ * @param {String} basePath - the absolute file path which will be prepended to the given relative paths.
+ * @returns {Promise.<Void>} - An empty promise to indicate the async processing has completed.
+ */
+function validateLibraries(versionData, basePath){
+    return new Promise(function(fulfill, reject){
+
+        const libArr = versionData.libraries
+        const libPath = path.join(basePath, 'libraries')
+
+        const libDlQueue = []
+        let dlSize = 0
+
+        //Check validity of each library. If the hashs don't match, download the library.
+        async.eachLimit(libArr, 5, function(lib, cb){
+            if(Library.validateRules(lib.rules)){
+                let artifact = (lib.natives == null) ? lib.downloads.artifact : lib.downloads.classifiers[lib.natives[Library.mojangFriendlyOS()]]
+                const libItm = new Library(lib.name, artifact.sha1, artifact.size, artifact.url, path.join(libPath, artifact.path))
+                if(!_validateLocal(libItm.to, 'sha1', libItm.hash)){
+                    dlSize += (libItm.size*1)
+                    libDlQueue.push(libItm)
+                }
+            }
+            cb()
+        }, function(err){
+            instance.libraries = new DLTracker(libDlQueue, dlSize)
+            instance.totaldlsize += dlSize
+            fulfill()
+        })
+    })
+}
+
+/**
+ * Public miscellaneous mojang file validation function. These files will be enqueued under
+ * the 'files' identifier.
+ * 
+ * @param {Object} versionData - the version data for the assets.
+ * @param {String} basePath - the absolute file path which will be prepended to the given relative paths.
+ * @returns {Promise.<Void>} - An empty promise to indicate the async processing has completed.
+ */
+function validateMiscellaneous(versionData, basePath){
+    return new Promise(async function(fulfill, reject){
+        await validateClient(versionData, basePath)
+        await validateLogConfig(versionData, basePath)
+        fulfill()
+    })
+}
+
+/**
+ * Validate client file - artifact renamed from client.jar to '{version}'.jar.
+ * 
+ * @param {Object} versionData - the version data for the assets.
+ * @param {String} basePath - the absolute file path which will be prepended to the given relative paths.
+ * @param {Boolean} force - optional. If true, the asset index will be downloaded even if it exists locally. Defaults to false.
+ * @returns {Promise.<Void>} - An empty promise to indicate the async processing has completed.
+ */
+function validateClient(versionData, basePath, force = false){
+    return new Promise(function(fulfill, reject){
+        const clientData = versionData.downloads.client
+        const version = versionData.id
+        const targetPath = path.join(basePath, 'versions', version)
+        const targetFile = version + '.jar'
+
+        let client = new Asset(version + ' client', clientData.sha1, clientData.size, clientData.url, path.join(targetPath, targetFile))
+
+        if(!_validateLocal(client.to, 'sha1', client.hash) || force){
+            instance.files.dlqueue.push(client)
+            instance.files.dlsize += client.size*1
+            fulfill()
+        } else {
+            fulfill()
+        }
+    })
+}
+
+/**
+ * Validate log config.
+ * 
+ * @param {Object} versionData - the version data for the assets.
+ * @param {String} basePath - the absolute file path which will be prepended to the given relative paths.
+ * @param {Boolean} force - optional. If true, the asset index will be downloaded even if it exists locally. Defaults to false.
+ * @returns {Promise.<Void>} - An empty promise to indicate the async processing has completed.
+ */
+function validateLogConfig(versionData, basePath){
+    return new Promise(function(fulfill, reject){
+        const client = versionData.logging.client
+        const file = client.file
+        const targetPath = path.join(basePath, 'assets', 'log_configs')
+
+        let logConfig = new Asset(file.id, file.sha1, file.size, file.url, path.join(targetPath, file.id))
+
+        if(!_validateLocal(logConfig.to, 'sha1', logConfig.hash)){
+            instance.files.dlqueue.push(logConfig)
+            instance.files.dlsize += client.size*1
+            fulfill()
+        } else {
+            fulfill()
+        }
+    })
+}
+
+/**
+ * This function will initiate the download processed for the specified identifiers. If no argument is
+ * given, all identifiers will be initiated. Note that in order for files to be processed you need to run
+ * the processing function corresponding to that identifier. If you run this function without processing
+ * the files, it is likely nothing will be enqueued in the global object and processing will complete
+ * immediately. Once all downloads are complete, this function will fire the 'dlcomplete' event on the
+ * global object instance.
+ * 
+ * @param {Array.<{id: string, limit: number}>} identifiers - optional. The identifiers to process and corresponding parallel async task limit.
+ */
+function processDlQueues(identifiers = [{id:'assets', limit:20}, {id:'libraries', limit:5}, {id:'files', limit:5}]){
+    this.progress = 0;
+    let win = remote.getCurrentWindow()
+
+    let shouldFire = true
+
+    for(let i=0; i<identifiers.length; i++){
+        let iden = identifiers[i]
+        let r = startAsyncProcess(iden.id, iden.limit)
+        if(r) shouldFire = false
+    }
+
+    if(shouldFire){
+        instance.emit('dlcomplete')
+    }
+}
+
+module.exports = {
+    loadVersionData,
+    validateAssets,
+    validateLibraries,
+    validateMiscellaneous,
+    processDlQueues,
+    instance,
+    Asset,
+    Library
+}

app/assets/js/launchindex.json

@@ -0,0 +1,75 @@
+{
+    "version": "1.0",
+    "servers": [
+        {
+            "id": "WesterosCraft-1.11.2",
+            "name": "WesterosCraft Production Client",
+            "news-feed": "http://www.westeroscraft.com/api/rss.php?preset_id=12700544",
+            "icon-url": "http://mc.westeroscraft.com/WesterosCraftLauncher/files/server-prod.png",
+            "revision": "0.0.1",
+            "server-ip": "mc.westeroscraft.com",
+            "mc-version": "1.11.2",
+            "main-class": "TBD",
+            "libraries": [
+                {
+                    "name": "net.minecraftforge.forge.forge-universal:1.11.2-13.20.0.2228",
+                    "required": true,
+                    "artifact": {
+                        "size": 4123353,
+                        "MD5": "5b9105f1a8552beac0c8228203d994ae",
+                        "path": "net/minecraftforge/forge/1.11.2-13.20.0.2228/forge-1.11.2-13.20.0.2228-universal.jar",
+                        "url": "http://files.minecraftforge.net/maven/net/minecraftforge/forge/1.11.2-13.20.0.2228/forge-1.11.2-13.20.0.2228-universal.jar"
+                    },
+                    "launch-args": ["--tweakClass cpw.mods.fml.common.launcher.FMLTweaker"]
+                },
+                {
+                    "name": "net.optifine.optifine:1.11.2_HD_U_B8",
+                    "required": true,
+                    "artifact": {
+                        "size": 2050307,
+                        "MD5": "c18c80f8bfa2a440cc5af4ab8816bc4b",
+                        "path": "optifine/OptiFine/1.11.2_HD_U_B8/OptiFine-1.11.2_HD_U_B8.jar",
+                        "url": "http://optifine.net/download.php?f=OptiFine_1.11.2_HD_U_B8.jar"
+                    },
+                    "launch-args": []
+                }
+            ],
+            "forgemods": [
+                {
+                    "name": "MODNAME",
+                    "required": true,
+                    "artifact": {
+                        "size": 1234,
+                         "MD5": "e71e88c744588fdad48d3b3beb4935fc",
+                        "path": "/path/to/lib/modname.jar",
+                        "url": "http://mc.westeroscraft.com/WesterosCraftLauncher/files/1.7.10/launchwrapper-1.11.jar"
+                    }
+                }
+            ],
+            "litemods": [
+                {
+                    "name": "MODNAME",
+                    "required": true,
+                    "artifact": {
+                        "size": 1234,
+                        "MD5": "e71e88c744588fdad48d3b3beb4935fc",
+                        "path": "/path/to/lib/modname.jar",
+                        "url": "http://mc.westeroscraft.com/WesterosCraftLauncher/files/1.7.10/launchwrapper-1.11.jar"
+                    }
+                }
+            ],
+            "files": [
+                {
+                    "name": "FILENAME",
+                    "required": true,
+                    "artifact": {
+                        "size": 1234,
+                        "MD5": "e71e88c744588fdad48d3b3beb4935fc",
+                        "path": "/path/to/lib/filename.jar",
+                        "url": "http://mc.westeroscraft.com/WesterosCraftLauncher/files/1.7.10/launchwrapper-1.11.jar"
+                    }
+                }
+            ]
+        }
+    ]
+}

app/assets/js/launchprocess.js

@@ -0,0 +1,136 @@
+const mojang = require('mojang')
+const uuidV4 = require('uuid/v4')
+const path = require('path')
+const child_process = require('child_process')
+const ag = require('./assetguard.js')
+const fs = require('fs')
+const mkpath = require('mkdirp');
+
+/* TODO - convert native extraction to use adm-zip. Currently not functional due to removal of unzip module (it was bad) */
+launchMinecraft = function(versionData, basePath){
+    const authPromise = mojang.auth('EMAIL', 'PASS', uuidV4(), {
+        name: 'Minecraft',
+        version: 1
+    })
+    authPromise.then(function(data){
+        const args = finalizeArguments(versionData, data, basePath)
+        //TODO make this dynamic
+        const child = child_process.spawn('C:\\Program Files\\Java\\jre1.8.0_131\\bin\\javaw.exe', args)
+    })
+}
+
+finalizeArguments = function(versionData, authData, basePath){
+    const mcArgs = versionData['minecraftArguments']
+    const gameProfile = authData['selectedProfile']
+    const regex = new RegExp('\\${*(.*)}')
+    const argArr = mcArgs.split(' ')
+    argArr.unshift('net.minecraft.client.main.Main')
+    argArr.unshift(classpathArg(versionData, basePath))
+    argArr.unshift('-cp')
+    argArr.unshift('-Djava.library.path=' + path.join(basePath, 'natives'))
+    argArr.unshift('-Xmn128M')
+    argArr.unshift('-XX:-UseAdaptiveSizePolicy')
+    argArr.unshift('-XX:+CMSIncrementalMode')
+    argArr.unshift('-XX:+UseConcMarkSweepGC')
+    argArr.unshift('-Xmx1G')
+    for(let i=0; i<argArr.length; i++){
+        if(regex.test(argArr[i])){
+            const identifier = argArr[i].match(regex)[1]
+            let newVal = argArr[i]
+            switch(identifier){
+                case 'auth_player_name':
+                    newVal = gameProfile['name']
+                    break
+                case 'version_name':
+                    newVal = versionData['id']
+                    break
+                case 'game_directory':
+                    newVal = basePath
+                    break
+                case 'assets_root':
+                    newVal = path.join(basePath, 'assets')
+                    break
+                case 'assets_index_name':
+                    newVal = versionData['assets']
+                    break
+                case 'auth_uuid':
+                    newVal = gameProfile['id']
+                    break
+                case 'auth_access_token':
+                    newVal = authData['accessToken']
+                    break
+                case 'user_type':
+                    newVal = 'MOJANG'
+                    break
+                case 'version_type':
+                    newVal = versionData['type']
+                    break
+            }
+            argArr[i] = newVal
+        }
+    }
+
+    return argArr
+}
+
+classpathArg = function(versionData, basePath){
+    const libArr = versionData['libraries']
+    const libPath = path.join(basePath, 'libraries')
+    const nativePath = path.join(basePath, 'natives')
+    const version = versionData['id']
+    const cpArgs = [path.join(basePath, 'versions', version, version + '.jar')]
+    libArr.forEach(function(lib){
+        if(ag.Library.validateRules(lib['rules'])){
+            if(lib['natives'] == null){
+                const dlInfo = lib['downloads']
+                const artifact = dlInfo['artifact']
+                const to = path.join(libPath, artifact['path'])
+                cpArgs.push(to)
+            } else {
+                //Now we need to extract natives.
+                const natives = lib['natives']
+                const extractInst = lib['extract']
+                const exclusionArr = extractInst['exclude']
+                const opSys = ag.Library.mojangFriendlyOS()
+                const indexId = natives[opSys]
+                const dlInfo = lib['downloads']
+                const classifiers = dlInfo['classifiers']
+                const artifact = classifiers[indexId]
+
+                const to = path.join(libPath, artifact['path'])
+
+                fs.createReadStream(to).pipe(unzip.Parse()).on('entry', function(entry){
+                    const fileName = entry.path
+                    const type = entry.type
+                    const size = entry.size
+
+                    console.log(fileName)
+
+                    let shouldExclude = false
+
+                    exclusionArr.forEach(function(exclusion){
+                        if(exclusion.indexOf(fileName) > -1){
+                            shouldExclude = true
+                        }
+                    })
+
+                    if(shouldExclude){
+                        entry.autodrain()
+                    }
+                    else {
+                        mkpath.sync(path.join(nativePath, fileName, '..'))
+                        entry.pipe(fs.createWriteStream(path.join(nativePath, fileName)))
+                    }
+                })
+
+                cpArgs.push(to)
+            }
+        }
+    })
+
+    return cpArgs.join(';')
+}
+
+module.exports = {
+    launchMinecraft
+}

app/assets/js/script.js

@@ -0,0 +1,60 @@
+var $ = require('jQuery');
+const remote = require('electron').remote
+const shell = require('electron').shell
+const path = require('path')
+
+/* Open web links in the user's default browser. */
+$(document).on('click', 'a[href^="http"]', function(event) {
+    event.preventDefault();
+    //testdownloads()
+    shell.openExternal(this.href)
+});
+
+testdownloads = async function(){
+    const ag = require(path.join(__dirname, 'assets', 'js', 'assetguard.js'))
+    const lp = require(path.join(__dirname, 'assets', 'js', 'launchprocess.js'))
+    const basePath = path.join(__dirname, '..', 'mcfiles')
+    let versionData = await ag.loadVersionData('1.11.2', basePath)
+    await ag.validateAssets(versionData, basePath)
+    console.log('assets done')
+    await ag.validateLibraries(versionData, basePath)
+    console.log('libs done')
+    await ag.validateMiscellaneous(versionData, basePath)
+    console.log('files done')
+    ag.instance.on('dlcomplete', function(){
+        lp.launchMinecraft(versionData, basePath)
+    })
+    ag.processDlQueues()
+}
+
+/*Opens DevTools window if you type "wcdev" in sequence.
+  This will crash the program if you are using multiple
+  DevTools, for example the chrome debugger in VS Code. */
+const match = [87, 67, 68, 69, 86]
+let at = 0;
+
+document.addEventListener('keydown', function (e) {
+    switch(e.keyCode){
+        case match[0]:
+            if(at === 0) ++at
+            break
+        case match[1]:
+            if(at === 1) ++at
+            break
+        case match[2]:
+            if(at === 2) ++at
+            break
+        case match[3]:
+            if(at === 3) ++at
+        case match[4]:
+            if(at === 4) ++at
+            break
+        default:
+            at = 0
+    }
+    if(at === 5) {
+        var window = remote.getCurrentWindow()
+        window.toggleDevTools()
+        at = 0
+    }
+})

app/assets/js/windowutils.js

@@ -0,0 +1,44 @@
+const app = require('electron')
+const remote = require('electron').BrowserWindow
+
+/**
+ * Doesn't work yet.
+ */
+exports.setIconBadge = function(text){
+    if(process.platform === 'darwin'){
+        app.dock.setBadge('' + text)
+    } else if (process.platform === 'win32'){
+        const win = remote.getFocusedWindow()
+        if(text === ''){
+            win.setOverlayIcon(null, '')
+            return;
+        }
+
+        //Create badge
+        const canvas = document.createElement('canvas')
+        canvas.height = 140;
+        canvas.width = 140;
+        const ctx = canvas.getContext('2d')
+        ctx.fillStyle = '#a02d2a'
+        ctx.beginPath()
+        ctx.ellipse(70, 70, 70, 70, 0, 0, 2 * Math.PI)
+        ctx.fill()
+        ctx.textAlign = 'center'
+        ctx.fillStyle = 'white'
+
+        if(text.length > 2 ){
+            ctx.font = '75px sans-serif'
+            ctx.fillText('' + text, 70, 98)
+        } else if (text.length > 1){
+            ctx.font = '100px sans-serif'
+            ctx.fillText('' + text, 70, 105)
+        } else {
+            ctx.font = '125px sans-serif'
+            ctx.fillText('' + text, 70, 112)
+        }
+
+        const badgeDataURL = canvas.toDataURL()
+        const img = NativeImage.createFromDataURL(badgeDataURL)
+        win.setOverlayIcon(img, '' + text)
+    }
+}