@strixit/storyscript 0.0.0-stage → 1.0.0

package/scripts/postbuild.js

@@ -0,0 +1,179 @@
+import fs from 'fs';
+import {ZipArchive} from "archiver";
+import path, {resolve} from "path";
+import jsonfile from 'jsonfile';
+import sharp from 'sharp';
+import {execFile} from 'child_process'
+import which from "which";
+import {rootFolder} from "./helpers.js";
+
+const {readFileSync} = jsonfile;
+
+const nameModule = await import(path.resolve(rootFolder, 'currentGameName.js'));
+const gamePath = `${rootFolder}/src/Games/${nameModule.currentGameName}`;
+
+const resourcePath = resolve(rootFolder, `./dist/resources`);
+const tempResourcePath = path.join(resourcePath, '_tmp');
+const gameInfoPath = `${gamePath}/webroot/gameinfo.json`;
+
+export async function postBuild() {
+    const originalWarn = console.warn;
+    
+    // Override the console warn to silence vite pwa glob warnings on the resources folder. It is not always present
+    // in the dist, only when a game has resources.
+    console.warn = (...args) => {
+        if (args[0]?.includes('glob pattern')) return;
+        originalWarn(...args);
+    };
+    
+    let gameInfo;
+
+    if (fs.existsSync(gameInfoPath)) {
+        gameInfo = readFileSync(gameInfoPath);
+    }
+
+    // 1. Include the game sources if specified to do so.
+    if (gameInfo?.sourcesIncluded) {
+        fs.cpSync(gamePath, 'dist/sources', {recursive: true});
+
+        if (fs.existsSync('dist/sources/resources')) {
+            fs.rmSync('dist/sources/resources', {recursive: true});
+        }
+
+        await zipDirectory('dist/sources', 'dist/sources.zip');
+        fs.rmSync('dist/sources', {recursive: true});
+    }
+
+    // 2. Optimize jpg and png images using sharp.
+    const imageFiles = getFiles(resourcePath, ['.jpg', '.png', 'webp']);
+
+    if (imageFiles?.length) {
+        await optimizeFiles('images', imageFiles, async (filePath, tempPath) => {
+            const sharpStream = sharp(filePath);
+            if (filePath.indexOf('.png') > -1) {
+                await sharpStream.png({quality: 80}).toFile(tempPath);
+            } else if (filePath.indexOf('.jpg') > -1) {
+                await sharpStream.jpeg({quality: 80}).toFile(tempPath);
+            } else if (filePath.indexOf('.webp') > -1) {
+                await sharpStream.webp({quality: 80}).toFile(tempPath);
+            }
+        });
+    }
+
+    // 3. Optimize sound files using FFmpeg.
+    const soundFiles = getFiles(resourcePath, ['.mp3']);
+
+    if (soundFiles?.length) {
+
+        // Check if FFmpeg is available on the system. If not, log a warning.
+        const ffmpegPath = await which('ffmpeg').catch(() => null);
+
+        if (!ffmpegPath) {
+            console.warn('FFmpeg is not installed. Please install it to optimize sound files.');
+        } else {
+            await optimizeFiles('sounds', soundFiles, async (filePath, tempPath) => {
+                execFile(ffmpegPath, ['-i', filePath, '-b:a', '64k', tempPath], (error) => {
+                    if (error) {
+                        console.error(`Error converting ${filePath}:`, error.message);
+                    } else {
+                        resolve(filePath);
+                    }
+                });
+            });
+        }
+    }
+}
+
+async function optimizeFiles(type, files, conversionFunc) {
+    console.log(`Optimize ${type}`)
+
+    await Promise.all(files.map(async (file) => {
+        const subdirectory = path.join(resourcePath, '_tmp', file.subdirectory);
+
+        if (!fs.existsSync(subdirectory)) {
+            fs.mkdirSync(subdirectory, {recursive: true});
+        }
+
+        const filePath = path.join(resourcePath, file.subdirectory, file.filepath);
+        const tempPath = path.join(tempResourcePath, file.subdirectory, file.filepath);
+
+        await conversionFunc(filePath, tempPath);
+    }));
+
+    console.log(`Replace ${type} with optimized versions`);
+
+    await Promise.all(files.map(async (file) => {
+        const filePath = path.join(resourcePath, file.subdirectory, file.filepath);
+        const tempPath = path.join(tempResourcePath, file.subdirectory, file.filepath);
+        await waitForFileReady(tempPath);
+        await fs.promises.rename(tempPath, filePath);
+    }));
+
+    if (fs.existsSync(tempResourcePath)) {
+        fs.rmSync(tempResourcePath, {recursive: true});
+    }
+}
+
+function getFiles(dirPath, extensions, arrayOfFiles) {
+    arrayOfFiles = arrayOfFiles || [];
+
+    if (!fs.existsSync(dirPath)) {
+        return;
+    }
+
+    const files = fs.readdirSync(dirPath);
+
+    files.forEach(function (file) {
+        if (fs.statSync(dirPath + "/" + file).isDirectory()) {
+            arrayOfFiles = getFiles(dirPath + "/" + file, extensions, arrayOfFiles);
+        } else if (extensions.find(e => file.indexOf(e) > -1)) {
+            const subdirectory = dirPath.replace(resourcePath, '');
+            arrayOfFiles.push({filepath: file, subdirectory: subdirectory});
+        }
+    })
+
+    return arrayOfFiles;
+}
+
+function zipDirectory(sourceDir, outPath) {
+    const archive = new ZipArchive({zlib: {level: 9}});
+    const stream = fs.createWriteStream(outPath);
+
+    return new Promise(async (resolve, reject) => {
+        archive
+            .directory(sourceDir, false)
+            .on('error', err => reject(err))
+            .pipe(stream)
+        ;
+
+        stream.on('close', () => resolve());
+        await archive.finalize();
+    });
+}
+
+async function waitForFileReady(filePath, maxWaitTime = 5000) {
+    const startTime = Date.now();
+    let lastSize = 0;
+    let stableCount = 0;
+
+    while (Date.now() - startTime < maxWaitTime) {
+        try {
+            const stat = await fs.promises.stat(filePath);
+
+            // If file size hasn't changed for 2 checks, it's ready
+            if (stat.size === lastSize) {
+                stableCount++;
+                if (stableCount >= 2) return true;
+            } else {
+                stableCount = 0;
+            }
+
+            lastSize = stat.size;
+            await new Promise(resolve => setTimeout(resolve, 100));
+        } catch (error) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+
+    return true;
+}

package/scripts/setupTesting.js

@@ -0,0 +1,17 @@
+import {rootFolder} from "./helpers.js";
+import {fileURLToPath} from "url";
+import path from "path";
+import pkg from "fs-extra";
+import fs from "fs";
+
+const {copy} = pkg;
+const __filename = fileURLToPath(import.meta.url);
+let __dirname = path.resolve(path.dirname(__filename), '../');
+
+const testRoot = `${__dirname}/src/Tests/Games/_GameTemplate`;
+const nameModule = await import(path.resolve(rootFolder, 'currentGameName.js'));
+const testDestination = `${rootFolder}/src/Tests/Games/${nameModule.currentGameName}`;
+
+if (!fs.existsSync(testDestination)) {
+    await copy(testRoot, testDestination);
+}

package/shims-vue.d.ts

@@ -0,0 +1 @@
+declare module '*.vue';

package/src/Engine/Actions/index.ts

@@ -0,0 +1,2 @@
+export { Open } from './open';
+export { OpenWithKey } from './openWithKey';

package/src/Engine/Actions/open.ts

@@ -0,0 +1,12 @@
+import {IBarrier, IDestination, IGame, makeSerializeSafe} from 'storyScript';
+
+/**
+ * A basic function to remove a barrier and then execute a callback function.
+ * @param callback
+ */
+export function Open(callback?: (game: IGame, barrier: [string, IBarrier], destination: IDestination) => void) {
+    return makeSerializeSafe((game: IGame, barrier: [string, IBarrier], destination: IDestination): void => {
+        destination.barriers.delete(barrier);
+        callback?.(game, barrier, destination);
+    }, callback);
+}

package/src/Engine/Actions/openWithKey.ts

@@ -0,0 +1,23 @@
+import {IBarrier, IDestination, IGame, IKey, makeSerializeSafe} from 'storyScript';
+
+/**
+ * A basic function to remove a barrier using a key and then execute a callback function. When it is not specified that the player
+ * should keep the key after using it, it is removed from his item list.
+ * @param callback The callback function to invoke after the barrier is removed.
+ */
+export function OpenWithKey(callback?: (game: IGame, barrier: [string, IBarrier], destination: IDestination) => void) {
+    return makeSerializeSafe((game: IGame, barrier: [string, IBarrier], destination: IDestination) => {
+        const key = typeof barrier[1].key === 'function' ? barrier[1].key() : <IKey>game.helpers.getItem(barrier[1].key);
+
+        if (key.keepAfterUse === undefined || key.keepAfterUse !== true) {
+            game.party.characters.forEach(c => {
+                c.items.delete(barrier[1].key);
+            });
+
+            game.currentLocation.items.delete(barrier[1].key);
+        }
+
+        destination.barriers.delete(barrier);
+        callback?.(game, barrier, destination);
+    }, callback);
+}