2021-02-01 17:09:15 -08:00
var Module ;
if ( typeof Module === 'undefined' ) Module = eval ( '(function() { try { return Module || {} } catch(e) { return {} } })()' ) ;
if ( ! Module . expectedDataFileDownloads ) {
Module . expectedDataFileDownloads = 0 ;
Module . finishedDataFileDownloads = 0 ;
}
Module . expectedDataFileDownloads ++ ;
( function ( ) {
var loadPackage = function ( metadata ) {
var PACKAGE _PATH ;
if ( typeof window === 'object' ) {
PACKAGE _PATH = window [ 'encodeURIComponent' ] ( window . location . pathname . toString ( ) . substring ( 0 , window . location . pathname . toString ( ) . lastIndexOf ( '/' ) ) + '/' ) ;
} else if ( typeof location !== 'undefined' ) {
// worker
PACKAGE _PATH = encodeURIComponent ( location . pathname . toString ( ) . substring ( 0 , location . pathname . toString ( ) . lastIndexOf ( '/' ) ) + '/' ) ;
} else {
throw 'using preloaded data can only be done on a web page or in a web worker' ;
}
2021-09-12 22:15:26 -07:00
var PACKAGE _NAME = 'game.love' ;
var REMOTE _PACKAGE _BASE = 'game.love' ;
2021-02-01 17:09:15 -08:00
if ( typeof Module [ 'locateFilePackage' ] === 'function' && ! Module [ 'locateFile' ] ) {
Module [ 'locateFile' ] = Module [ 'locateFilePackage' ] ;
Module . printErr ( 'warning: you defined Module.locateFilePackage, that has been renamed to Module.locateFile (using your locateFilePackage for now)' ) ;
}
var REMOTE _PACKAGE _NAME = typeof Module [ 'locateFile' ] === 'function' ?
Module [ 'locateFile' ] ( REMOTE _PACKAGE _BASE ) :
( ( Module [ 'filePackagePrefixURL' ] || '' ) + REMOTE _PACKAGE _BASE ) ;
var REMOTE _PACKAGE _SIZE = metadata . remote _package _size ;
var PACKAGE _UUID = metadata . package _uuid ;
function fetchRemotePackage ( packageName , packageSize , callback , errback ) {
var xhr = new XMLHttpRequest ( ) ;
xhr . open ( 'GET' , packageName , true ) ;
xhr . responseType = 'arraybuffer' ;
xhr . onprogress = function ( event ) {
var url = packageName ;
var size = packageSize ;
if ( event . total ) size = event . total ;
if ( event . loaded ) {
if ( ! xhr . addedTotal ) {
xhr . addedTotal = true ;
if ( ! Module . dataFileDownloads ) Module . dataFileDownloads = { } ;
Module . dataFileDownloads [ url ] = {
loaded : event . loaded ,
total : size
} ;
} else {
Module . dataFileDownloads [ url ] . loaded = event . loaded ;
}
var total = 0 ;
var loaded = 0 ;
var num = 0 ;
for ( var download in Module . dataFileDownloads ) {
var data = Module . dataFileDownloads [ download ] ;
total += data . total ;
loaded += data . loaded ;
num ++ ;
}
total = Math . ceil ( total * Module . expectedDataFileDownloads / num ) ;
if ( Module [ 'setStatus' ] ) Module [ 'setStatus' ] ( 'Downloading data... (' + loaded + '/' + total + ')' ) ;
} else if ( ! Module . dataFileDownloads ) {
if ( Module [ 'setStatus' ] ) Module [ 'setStatus' ] ( 'Downloading data...' ) ;
}
} ;
xhr . onerror = function ( event ) {
throw new Error ( "NetworkError for: " + packageName ) ;
}
xhr . onload = function ( event ) {
if ( xhr . status == 200 || xhr . status == 304 || xhr . status == 206 || ( xhr . status == 0 && xhr . response ) ) { // file URLs can return 0
var packageData = xhr . response ;
callback ( packageData ) ;
} else {
throw new Error ( xhr . statusText + " : " + xhr . responseURL ) ;
}
} ;
xhr . send ( null ) ;
} ;
function handleError ( error ) {
console . error ( 'package error:' , error ) ;
} ;
function runWithFS ( ) {
function assert ( check , msg ) {
if ( ! check ) throw msg + new Error ( ) . stack ;
}
2021-09-12 22:15:26 -07:00
// {{{create_file_paths}}}
2021-02-01 17:09:15 -08:00
function DataRequest ( start , end , crunched , audio ) {
this . start = start ;
this . end = end ;
this . crunched = crunched ;
this . audio = audio ;
}
DataRequest . prototype = {
requests : { } ,
open : function ( mode , name ) {
this . name = name ;
this . requests [ name ] = this ;
Module [ 'addRunDependency' ] ( 'fp ' + this . name ) ;
} ,
send : function ( ) { } ,
onload : function ( ) {
var byteArray = this . byteArray . subarray ( this . start , this . end ) ;
this . finish ( byteArray ) ;
} ,
finish : function ( byteArray ) {
var that = this ;
Module [ 'FS_createDataFile' ] ( this . name , null , byteArray , true , true , true ) ; // canOwn this data in the filesystem, it is a slide into the heap that will never change
Module [ 'removeRunDependency' ] ( 'fp ' + that . name ) ;
this . requests [ this . name ] = null ;
}
} ;
var files = metadata . files ;
for ( i = 0 ; i < files . length ; ++ i ) {
new DataRequest ( files [ i ] . start , files [ i ] . end , files [ i ] . crunched , files [ i ] . audio ) . open ( 'GET' , files [ i ] . filename ) ;
}
var indexedDB = window . indexedDB || window . mozIndexedDB || window . webkitIndexedDB || window . msIndexedDB ;
var IDB _RO = "readonly" ;
var IDB _RW = "readwrite" ;
var DB _NAME = "EM_PRELOAD_CACHE" ;
var DB _VERSION = 1 ;
var METADATA _STORE _NAME = 'METADATA' ;
var PACKAGE _STORE _NAME = 'PACKAGES' ;
function openDatabase ( callback , errback ) {
try {
var openRequest = indexedDB . open ( DB _NAME , DB _VERSION ) ;
} catch ( e ) {
return errback ( e ) ;
}
openRequest . onupgradeneeded = function ( event ) {
var db = event . target . result ;
if ( db . objectStoreNames . contains ( PACKAGE _STORE _NAME ) ) {
db . deleteObjectStore ( PACKAGE _STORE _NAME ) ;
}
var packages = db . createObjectStore ( PACKAGE _STORE _NAME ) ;
if ( db . objectStoreNames . contains ( METADATA _STORE _NAME ) ) {
db . deleteObjectStore ( METADATA _STORE _NAME ) ;
}
var metadata = db . createObjectStore ( METADATA _STORE _NAME ) ;
} ;
openRequest . onsuccess = function ( event ) {
var db = event . target . result ;
callback ( db ) ;
} ;
openRequest . onerror = function ( error ) {
errback ( error ) ;
} ;
} ;
/* Check if there's a cached package, and if so whether it's the latest available */
function checkCachedPackage ( db , packageName , callback , errback ) {
var transaction = db . transaction ( [ METADATA _STORE _NAME ] , IDB _RO ) ;
var metadata = transaction . objectStore ( METADATA _STORE _NAME ) ;
var getRequest = metadata . get ( "metadata/" + packageName ) ;
getRequest . onsuccess = function ( event ) {
var result = event . target . result ;
if ( ! result ) {
return callback ( false ) ;
} else {
return callback ( PACKAGE _UUID === result . uuid ) ;
}
} ;
getRequest . onerror = function ( error ) {
errback ( error ) ;
} ;
} ;
function fetchCachedPackage ( db , packageName , callback , errback ) {
var transaction = db . transaction ( [ PACKAGE _STORE _NAME ] , IDB _RO ) ;
var packages = transaction . objectStore ( PACKAGE _STORE _NAME ) ;
var getRequest = packages . get ( "package/" + packageName ) ;
getRequest . onsuccess = function ( event ) {
var result = event . target . result ;
callback ( result ) ;
} ;
getRequest . onerror = function ( error ) {
errback ( error ) ;
} ;
} ;
function cacheRemotePackage ( db , packageName , packageData , packageMeta , callback , errback ) {
var transaction _packages = db . transaction ( [ PACKAGE _STORE _NAME ] , IDB _RW ) ;
var packages = transaction _packages . objectStore ( PACKAGE _STORE _NAME ) ;
var putPackageRequest = packages . put ( packageData , "package/" + packageName ) ;
putPackageRequest . onsuccess = function ( event ) {
var transaction _metadata = db . transaction ( [ METADATA _STORE _NAME ] , IDB _RW ) ;
var metadata = transaction _metadata . objectStore ( METADATA _STORE _NAME ) ;
var putMetadataRequest = metadata . put ( packageMeta , "metadata/" + packageName ) ;
putMetadataRequest . onsuccess = function ( event ) {
callback ( packageData ) ;
} ;
putMetadataRequest . onerror = function ( error ) {
errback ( error ) ;
} ;
} ;
putPackageRequest . onerror = function ( error ) {
errback ( error ) ;
} ;
} ;
function processPackageData ( arrayBuffer ) {
Module . finishedDataFileDownloads ++ ;
assert ( arrayBuffer , 'Loading data file failed.' ) ;
assert ( arrayBuffer instanceof ArrayBuffer , 'bad input to processPackageData' ) ;
var byteArray = new Uint8Array ( arrayBuffer ) ;
var curr ;
// copy the entire loaded file into a spot in the heap. Files will refer to slices in that. They cannot be freed though
// (we may be allocating before malloc is ready, during startup).
if ( Module [ 'SPLIT_MEMORY' ] ) Module . printErr ( 'warning: you should run the file packager with --no-heap-copy when SPLIT_MEMORY is used, otherwise copying into the heap may fail due to the splitting' ) ;
var ptr = Module [ 'getMemory' ] ( byteArray . length ) ;
Module [ 'HEAPU8' ] . set ( byteArray , ptr ) ;
DataRequest . prototype . byteArray = Module [ 'HEAPU8' ] . subarray ( ptr , ptr + byteArray . length ) ;
var files = metadata . files ;
for ( i = 0 ; i < files . length ; ++ i ) {
DataRequest . prototype . requests [ files [ i ] . filename ] . onload ( ) ;
}
Module [ 'removeRunDependency' ] ( 'datafile_game.data' ) ;
} ;
Module [ 'addRunDependency' ] ( 'datafile_game.data' ) ;
if ( ! Module . preloadResults ) Module . preloadResults = { } ;
function preloadFallback ( error ) {
console . error ( error ) ;
console . error ( 'falling back to default preload behavior' ) ;
fetchRemotePackage ( REMOTE _PACKAGE _NAME , REMOTE _PACKAGE _SIZE , processPackageData , handleError ) ;
} ;
openDatabase (
function ( db ) {
checkCachedPackage ( db , PACKAGE _PATH + PACKAGE _NAME ,
function ( useCached ) {
Module . preloadResults [ PACKAGE _NAME ] = { fromCache : useCached } ;
if ( useCached ) {
console . info ( 'loading ' + PACKAGE _NAME + ' from cache' ) ;
fetchCachedPackage ( db , PACKAGE _PATH + PACKAGE _NAME , processPackageData , preloadFallback ) ;
} else {
console . info ( 'loading ' + PACKAGE _NAME + ' from remote' ) ;
fetchRemotePackage ( REMOTE _PACKAGE _NAME , REMOTE _PACKAGE _SIZE ,
function ( packageData ) {
cacheRemotePackage ( db , PACKAGE _PATH + PACKAGE _NAME , packageData , { uuid : PACKAGE _UUID } , processPackageData ,
function ( error ) {
console . error ( error ) ;
processPackageData ( packageData ) ;
} ) ;
}
, preloadFallback ) ;
}
}
, preloadFallback ) ;
}
, preloadFallback ) ;
if ( Module [ 'setStatus' ] ) Module [ 'setStatus' ] ( 'Downloading...' ) ;
}
if ( Module [ 'calledRun' ] ) {
runWithFS ( ) ;
} else {
if ( ! Module [ 'preRun' ] ) Module [ 'preRun' ] = [ ] ;
Module [ "preRun" ] . push ( runWithFS ) ; // FS is not initialized yet, wait for it
}
}
loadPackage ( { { { metadata } } } ) ;
} ) ( ) ;