@skillprint/cocos-sdk 0.0.1

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@skillprint/cocos-sdk",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Skillprint SDK for Cocos Creator 3.x",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "peerDependencies": {
+    "cc": "*"
+  }
+}

package/src/ScreenshotUtility.ts

@@ -0,0 +1,257 @@
+import { Camera, RenderTexture, view, sys, native, director, Director } from 'cc';
+
+export class ScreenshotUtility {
+    private logger: ((msg: string, level: 'Info' | 'Warning' | 'Error') => void) | null = null;
+
+    constructor(logger?: (msg: string, level: 'Info' | 'Warning' | 'Error') => void) {
+        if (logger) {
+            this.logger = logger;
+        }
+    }
+
+    private log(msg: string, level: 'Info' | 'Warning' | 'Error' = 'Info') {
+        if (this.logger) {
+            this.logger(msg, level);
+        } else {
+            const prefix = `[ScreenshotUtility] [${level}]`;
+            if (level === 'Error') {
+                console.error(`${prefix} ${msg}`);
+            } else if (level === 'Warning') {
+                console.warn(`${prefix} ${msg}`);
+            } else {
+                console.log(`${prefix} ${msg}`);
+            }
+        }
+    }
+
+    /**
+     * Captures a screenshot from the specified camera, flips it vertically,
+     * downscales it if necessary, and returns a JPEG Blob (Web) or ArrayBuffer (Native).
+     */
+    public async captureScreenshot(
+        camera: Camera,
+        maxWidth: number = 960,
+        jpegQuality: number = 60
+    ): Promise<Blob | ArrayBuffer | null> {
+        if (!camera) {
+            this.log('Cannot capture: Camera is null', 'Error');
+            return null;
+        }
+
+        try {
+            const visibleSize = view.getVisibleSize();
+            const width = Math.floor(visibleSize.width);
+            const height = Math.floor(visibleSize.height);
+
+            this.log(`Capturing screenshot: resolution ${width}x${height}`, 'Info');
+
+            // 1. Create RenderTexture
+            const renderTexture = new RenderTexture();
+            renderTexture.reset({
+                width: width,
+                height: height
+            });
+
+            // 2. Render camera into the texture by waiting for the render pipeline cycle
+            const prevTarget = camera.targetTexture;
+            camera.targetTexture = renderTexture;
+            
+            await new Promise<void>((resolve) => {
+                director.once(Director.EVENT_AFTER_RENDER, resolve);
+            });
+            
+            camera.targetTexture = prevTarget; // restore camera settings
+
+            // 3. Read pixels from GPU
+            const pixelBuffer = new Uint8Array(width * height * 4);
+            renderTexture.readPixels(0, 0, width, height, pixelBuffer);
+
+            // Clean up RenderTexture immediately to free GPU memory
+            renderTexture.destroy();
+
+            // 4. Flip pixel coordinates vertically (WebGL reads bottom-to-top)
+            this.flipY(pixelBuffer, width, height);
+
+            // 5. Handle Platform-Specific Encoding
+            if (sys.isBrowser) {
+                return await this.encodeOnWeb(pixelBuffer, width, height, maxWidth, jpegQuality);
+            } else if (sys.isNative && !!native && typeof native.saveImageData === 'function') {
+                return await this.encodeOnNative(pixelBuffer, width, height, maxWidth, jpegQuality);
+            } else {
+                this.log('Platform not supported for screenshot encoding. Returning raw buffer.', 'Warning');
+                return pixelBuffer.buffer;
+            }
+        } catch (err: any) {
+            this.log(`Failed to capture screenshot: ${err.message || err}`, 'Error');
+            return null;
+        }
+    }
+
+    /**
+     * Vertically flips the raw pixel buffer in-place.
+     */
+    private flipY(pixels: Uint8Array, width: number, height: number) {
+        const rowBytes = width * 4;
+        const tempRow = new Uint8Array(rowBytes);
+        for (let row = 0; row < Math.floor(height / 2); row++) {
+            const topOffset = row * rowBytes;
+            const bottomOffset = (height - 1 - row) * rowBytes;
+            // Swap top and bottom rows
+            tempRow.set(pixels.subarray(topOffset, topOffset + rowBytes));
+            pixels.set(pixels.subarray(bottomOffset, bottomOffset + rowBytes), topOffset);
+            pixels.set(tempRow, bottomOffset);
+        }
+    }
+
+    /**
+     * HTML5 Canvas based JPEG encoder and scaling for web platforms
+     */
+    private encodeOnWeb(
+        pixels: Uint8Array,
+        width: number,
+        height: number,
+        maxWidth: number,
+        jpegQuality: number
+    ): Promise<Blob | null> {
+        return new Promise((resolve) => {
+            try {
+                // Determine target dimensions
+                let destWidth = width;
+                let destHeight = height;
+                if (maxWidth > 0 && width > maxWidth) {
+                    const scale = maxWidth / width;
+                    destWidth = maxWidth;
+                    destHeight = Math.floor(height * scale);
+                }
+
+                // Create offscreen canvas for rendering
+                const canvas = document.createElement('canvas');
+                canvas.width = destWidth;
+                canvas.height = destHeight;
+                const ctx = canvas.getContext('2d');
+
+                if (!ctx) {
+                    this.log('Could not get HTML5 canvas 2D context', 'Error');
+                    resolve(null);
+                    return;
+                }
+
+                if (destWidth === width && destHeight === height) {
+                    // Direct copy
+                    const imgData = ctx.createImageData(width, height);
+                    imgData.data.set(pixels);
+                    ctx.putImageData(imgData, 0, 0);
+                } else {
+                    // Downscale using intermediate canvas drawing
+                    const srcCanvas = document.createElement('canvas');
+                    srcCanvas.width = width;
+                    srcCanvas.height = height;
+                    const srcCtx = srcCanvas.getContext('2d');
+                    if (srcCtx) {
+                        const imgData = srcCtx.createImageData(width, height);
+                        imgData.data.set(pixels);
+                        srcCtx.putImageData(imgData, 0, 0);
+                        // Render downscaled image
+                        ctx.drawImage(srcCanvas, 0, 0, destWidth, destHeight);
+                    } else {
+                        resolve(null);
+                        return;
+                    }
+                }
+
+                const qualityFactor = Math.max(0.01, Math.min(1.0, jpegQuality / 100));
+                canvas.toBlob((blob) => {
+                    resolve(blob);
+                }, 'image/jpeg', qualityFactor);
+            } catch (err: any) {
+                this.log(`Web encoding failed: ${err.message || err}`, 'Error');
+                resolve(null);
+            }
+        });
+    }
+
+    /**
+     * Native file and image API based JPEG encoder for Android/iOS/Desktop
+     */
+    private async encodeOnNative(
+        pixels: Uint8Array,
+        width: number,
+        height: number,
+        maxWidth: number,
+        jpegQuality: number
+    ): Promise<ArrayBuffer | null> {
+        try {
+            // Note: Cocos Creator Native saveImageData saves raw pixel buffers to file.
+            // Under the hood, if the filename has a .jpg extension, it handles JPEG compression.
+            const writablePath = native.fileUtils.getWritablePath();
+            const filePath = `${writablePath}temp_screenshot.jpg`;
+
+            // If downscaling is needed natively, we pass smaller dimensions if native API supports scaling, 
+            // otherwise saveImageData handles saving raw buffer.
+            let targetWidth = width;
+            let targetHeight = height;
+            let finalPixels = pixels;
+
+            if (maxWidth > 0 && width > maxWidth) {
+                const scale = maxWidth / width;
+                targetWidth = maxWidth;
+                targetHeight = Math.floor(height * scale);
+                // Perform a simple downsampling if size is reduced (e.g. skip pixels)
+                // In Cocos 3.x, saveImageData is standard, so we can save it and let the engine compress it.
+                // We'll downsample finalPixels array to match target size
+                finalPixels = this.downsamplePixels(pixels, width, height, targetWidth, targetHeight);
+            }
+
+            // Save image using Cocos native APIs (saves as JPEG on .jpg extension)
+            // Note: native.saveImageData returns a Promise or runs synchronously. In 3.8.x, it returns a Promise.
+            await native.saveImageData(finalPixels, targetWidth, targetHeight, filePath);
+
+            // Read the saved file back into memory
+            const arrayBuffer = native.fileUtils.getDataFromFile(filePath);
+
+            // Clean up the temporary file
+            native.fileUtils.removeFile(filePath);
+
+            if (arrayBuffer && arrayBuffer.byteLength > 0) {
+                this.log(`Native screenshot encoded successfully. Size: ${arrayBuffer.byteLength} bytes`, 'Info');
+                return arrayBuffer;
+            } else {
+                this.log('Failed to read native saved screenshot back from local storage', 'Error');
+                return null;
+            }
+        } catch (err: any) {
+            this.log(`Native encoding failed: ${err.message || err}`, 'Error');
+            return null;
+        }
+    }
+
+    /**
+     * Simple pixel downsampling helper for native builds without canvas API
+     */
+    private downsamplePixels(
+        pixels: Uint8Array,
+        srcW: number,
+        srcH: number,
+        destW: number,
+        destH: number
+    ): Uint8Array {
+        const destPixels = new Uint8Array(destW * destH * 4);
+        const xRatio = srcW / destW;
+        const yRatio = srcH / destH;
+
+        for (let y = 0; y < destH; y++) {
+            for (let x = 0; x < destW; x++) {
+                const srcX = Math.floor(x * xRatio);
+                const srcY = Math.floor(y * yRatio);
+                const srcIdx = (srcY * srcW + srcX) * 4;
+                const destIdx = (y * destW + x) * 4;
+
+                destPixels[destIdx] = pixels[srcIdx];       // R
+                destPixels[destIdx + 1] = pixels[srcIdx + 1]; // G
+                destPixels[destIdx + 2] = pixels[srcIdx + 2]; // B
+                destPixels[destIdx + 3] = pixels[srcIdx + 3]; // A
+            }
+        }
+        return destPixels;
+    }
+}

package/src/SkillprintAPIClient.ts

@@ -0,0 +1,323 @@
+import { ParameterInfo, ParameterUpdateResult, PollResultsResponse } from './SkillprintTypes';
+
+export class SkillprintAPIClient {
+    private baseUrl: string;
+    private partnerApiKey: string;
+    private userToken: string | null = null;
+    private logger: ((msg: string, level: 'Info' | 'Warning' | 'Error') => void) | null = null;
+
+    // Endpoints
+    private static readonly START_SESSION_ENDPOINT = '/games/api/sessions/';
+    private static readonly UPLOAD_SCREENSHOTS_ENDPOINT = '/games/api/record-session/{sessionId}/';
+    private static readonly POLL_RESULTS_ENDPOINT = '/games/api/sessions/{sessionId}/';
+    private static readonly CREATE_USER_ENDPOINT = '/partners/api/users/add/';
+    private static readonly GET_USER_TOKEN_ENDPOINT = '/partners/api/users/auth/token/';
+
+    // Retry settings
+    private static readonly MAX_UPLOAD_RETRIES = 2;
+    private static readonly RETRY_BASE_DELAY_MS = 1000;
+
+    constructor(
+        baseUrl: string,
+        partnerApiKey: string,
+        logger?: (msg: string, level: 'Info' | 'Warning' | 'Error') => void
+    ) {
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.partnerApiKey = partnerApiKey;
+        if (logger) {
+            this.logger = logger;
+        }
+    }
+
+    private log(msg: string, level: 'Info' | 'Warning' | 'Error' = 'Info') {
+        if (this.logger) {
+            this.logger(msg, level);
+        } else {
+            const prefix = `[SkillprintAPIClient] [${level}]`;
+            if (level === 'Error') {
+                console.error(`${prefix} ${msg}`);
+            } else if (level === 'Warning') {
+                console.warn(`${prefix} ${msg}`);
+            } else {
+                console.log(`${prefix} ${msg}`);
+            }
+        }
+    }
+
+    public async startSession(
+        sessionId: string,
+        targetMood: string,
+        customPlayerId: string | null,
+        gameName: string,
+        gameParameters: ParameterInfo[]
+    ): Promise<boolean> {
+        const url = `${this.baseUrl}${SkillprintAPIClient.START_SESSION_ENDPOINT}`;
+        this.log(`Starting session: POST ${url}`, 'Info');
+        this.log(`Starting session: MOOD ${targetMood}`, 'Warning');
+
+        // Provision/retrieve user token if customPlayerId is provided
+        if (customPlayerId) {
+            try {
+                this.userToken = await this.createOrGetUserToken(customPlayerId);
+                if (this.userToken) {
+                    this.log(`User token obtained successfully for player: ${customPlayerId}`, 'Info');
+                } else {
+                    this.log(`Could not retrieve user token for player: ${customPlayerId}. Continuing without token.`, 'Warning');
+                }
+            } catch (err: any) {
+                this.log(`Error obtaining user token: ${err.message || err}. Continuing without token.`, 'Warning');
+            }
+        }
+
+        const requestData = {
+            sessionId: sessionId,
+            game: gameName,
+            targetMood: targetMood,
+            gameParameters: gameParameters
+        };
+
+        const headers: HeadersInit = {
+            'Content-Type': 'application/json',
+            'Authorization': `Api-Key ${this.partnerApiKey}`
+        };
+
+        if (this.userToken) {
+            headers['X-Auth-Token'] = `Token ${this.userToken}`;
+        }
+
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: headers,
+                body: JSON.stringify(requestData)
+            });
+
+            const text = await response.text();
+            if (response.ok) {
+                this.log(`StartSession successful. Response: ${text}`, 'Info');
+                return true;
+            } else {
+                this.log(`StartSession Error: ${response.statusText}. Response: ${text}`, 'Error');
+                return false;
+            }
+        } catch (err: any) {
+            this.log(`StartSession Network Error: ${err.message || err}`, 'Error');
+            return false;
+        }
+    }
+
+    public async postScreenshots(
+        sessionId: string,
+        screenshots: (Blob | ArrayBuffer)[],
+        isLastChunk: boolean
+    ): Promise<boolean> {
+        const endpoint = SkillprintAPIClient.UPLOAD_SCREENSHOTS_ENDPOINT.replace('{sessionId}', sessionId);
+        const url = `${this.baseUrl}${endpoint}`;
+        this.log(`Posting ${screenshots.length} screenshots (isLastChunk: ${isLastChunk}): POST ${url}`, 'Info');
+
+        if (screenshots.length === 0 && !isLastChunk) {
+            this.log(`No screenshots provided, and isLastChunk is false. Skipping.`, 'Warning');
+            return false;
+        }
+
+        let attempt = 0;
+        let succeeded = false;
+        let lastError = '';
+
+        while (attempt <= SkillprintAPIClient.MAX_UPLOAD_RETRIES && !succeeded) {
+            if (attempt > 0) {
+                const delay = SkillprintAPIClient.RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                this.log(`Retrying screenshot upload (attempt ${attempt + 1}/${SkillprintAPIClient.MAX_UPLOAD_RETRIES + 1}) after ${delay}ms...`, 'Warning');
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+
+            try {
+                const formData = new FormData();
+                formData.append('is_last_chunk', isLastChunk.toString().toLowerCase());
+
+                screenshots.forEach((screenshot, i) => {
+                    const blob = screenshot instanceof ArrayBuffer ? new Blob([screenshot], { type: 'image/jpeg' }) : screenshot;
+                    formData.append(`screenshot${i}`, blob, `screenshot_${i}.jpg`);
+                });
+
+                const headers: HeadersInit = {
+                    'Authorization': `Api-Key ${this.partnerApiKey}`
+                };
+                if (this.userToken) {
+                    headers['X-Auth-Token'] = `Token ${this.userToken}`;
+                }
+
+                // Note: Do not set Content-Type header when sending FormData.
+                // The browser will automatically set the correct multipart/form-data boundary.
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: headers,
+                    body: formData
+                });
+
+                const text = await response.text();
+                if (response.ok) {
+                    this.log(`PostScreenshots successful. Response: ${text}`, 'Info');
+                    succeeded = true;
+                } else {
+                    lastError = `Status: ${response.statusText} | Response: ${text}`;
+                    this.log(`PostScreenshots Error (attempt ${attempt + 1}): ${lastError}`, 'Error');
+                }
+            } catch (err: any) {
+                lastError = err.message || String(err);
+                this.log(`PostScreenshots Network Error (attempt ${attempt + 1}): ${lastError}`, 'Error');
+            }
+
+            attempt++;
+        }
+
+        if (!succeeded) {
+            this.log(`PostScreenshots failed after ${SkillprintAPIClient.MAX_UPLOAD_RETRIES + 1} attempts. Last error: ${lastError}`, 'Error');
+        }
+
+        return succeeded;
+    }
+
+    public async pollParameterResults(sessionId: string): Promise<ParameterUpdateResult[]> {
+        const endpoint = SkillprintAPIClient.POLL_RESULTS_ENDPOINT.replace('{sessionId}', sessionId);
+        const url = `${this.baseUrl}${endpoint}`;
+        this.log(`Polling results: GET ${url}`, 'Info');
+
+        const headers: HeadersInit = {
+            'Authorization': `Api-Key ${this.partnerApiKey}`,
+            'Accept': 'application/json'
+        };
+        if (this.userToken) {
+            headers['X-Auth-Token'] = `Token ${this.userToken}`;
+        }
+
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: headers
+            });
+
+            const text = await response.text();
+            if (response.ok) {
+                this.log(`PollResults successful. Response: ${text}`, 'Info');
+                let data: any;
+                try {
+                    data = JSON.parse(text);
+                } catch (jsonErr: any) {
+                    // Try parsing as array directly if it was wrapped or malformed
+                    if (text.trim().startsWith('[')) {
+                        data = { parameterUpdates: JSON.parse(text) };
+                    } else {
+                        throw jsonErr;
+                    }
+                }
+
+                let updates: ParameterUpdateResult[] = [];
+                if (data && Array.isArray(data.parameterUpdates)) {
+                    updates = data.parameterUpdates;
+                } else if (Array.isArray(data)) {
+                    updates = data;
+                }
+
+                // Map updates to extract the parsed values
+                updates.forEach((update) => {
+                    this.log(`Parameter Update: ${update.parameterName} = ${this.getParsedValue(update)}`, 'Info');
+                });
+
+                return updates;
+            } else {
+                this.log(`PollResults Error: ${response.statusText}. Response: ${text}`, 'Error');
+                return [];
+            }
+        } catch (err: any) {
+            this.log(`PollResults Error: ${err.message || err}`, 'Error');
+            return [];
+        }
+    }
+
+    public getParsedValue(update: ParameterUpdateResult): any {
+        // Retrieve the newValue or find the key with the parameterName (for legacy or alternative responses)
+        if (update.newValue !== undefined && update.newValue !== null) {
+            return update.newValue;
+        }
+        if (update.parameterName && update[update.parameterName] !== undefined) {
+            return update[update.parameterName];
+        }
+        return null;
+    }
+
+    public async createOrGetUserToken(customPlayerId: string): Promise<string | null> {
+        if (!customPlayerId) return null;
+
+        // Try getting token first
+        let token = await this.getUserToken(customPlayerId);
+        if (token) return token;
+
+        // User doesn't exist, create user
+        const created = await this.createUser(customPlayerId);
+        if (created) {
+            // Retrieve token again after creation
+            token = await this.getUserToken(customPlayerId);
+            return token;
+        }
+
+        return null;
+    }
+
+    private async createUser(internalId: string): Promise<boolean> {
+        const url = `${this.baseUrl}${SkillprintAPIClient.CREATE_USER_ENDPOINT}`;
+        this.log(`Creating user: POST ${url} with internalId: ${internalId}`, 'Info');
+
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Api-Key ${this.partnerApiKey}`
+                },
+                body: JSON.stringify({ internalId: internalId })
+            });
+
+            const text = await response.text();
+            if (response.ok) {
+                this.log(`CreateUser successful. Response: ${text}`, 'Info');
+                return true;
+            } else {
+                this.log(`CreateUser Error: ${response.statusText}. Response: ${text}`, 'Error');
+                return false;
+            }
+        } catch (err: any) {
+            this.log(`CreateUser Network Error: ${err.message || err}`, 'Error');
+            return false;
+        }
+    }
+
+    private async getUserToken(internalId: string): Promise<string | null> {
+        const url = `${this.baseUrl}${SkillprintAPIClient.GET_USER_TOKEN_ENDPOINT}`;
+        this.log(`Getting user token: POST ${url} with internalId: ${internalId}`, 'Info');
+
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Api-Key ${this.partnerApiKey}`
+                },
+                body: JSON.stringify({ internalId: internalId })
+            });
+
+            const text = await response.text();
+            if (response.ok) {
+                this.log(`GetUserToken successful. Response: ${text}`, 'Info');
+                const data = JSON.parse(text);
+                return data.token || null;
+            } else {
+                this.log(`GetUserToken Error: ${response.statusText}. Response: ${text}`, 'Error');
+                return null;
+            }
+        } catch (err: any) {
+            this.log(`GetUserToken Network Error: ${err.message || err}`, 'Error');
+            return null;
+        }
+    }
+}

package/src/SkillprintConfigComponent.ts

@@ -0,0 +1,91 @@
+import { _decorator, Component, Enum } from 'cc';
+import { ApiEnvironment, SkillprintConfig } from './SkillprintTypes';
+
+const { ccclass, property } = _decorator;
+
+Enum(ApiEnvironment);
+
+@ccclass('SkillprintConfigComponent')
+export class SkillprintConfigComponent extends Component {
+    @property({
+        displayName: 'Game Name (Slug)',
+        tooltip: 'The unique slug registered for your game, e.g. fruit-boom'
+    })
+    public gameName = 'cocos-demo-game';
+
+    @property({
+        type: Enum(ApiEnvironment),
+        displayName: 'Target Environment'
+    })
+    public targetEnvironment = ApiEnvironment.Staging;
+
+    @property({
+        displayName: 'Staging API Key',
+    })
+    public stagingPartnerApiKey = '';
+
+    @property({
+        displayName: 'Staging API Base URL'
+    })
+    public stagingApiBaseUrl = 'https://api.staging.skillprint.co';
+
+    @property({
+        displayName: 'Production API Key',
+    })
+    public productionPartnerApiKey = '';
+
+    @property({
+        displayName: 'Production API Base URL'
+    })
+    public productionApiBaseUrl = 'https://api.skillprint.co';
+
+    @property({
+        displayName: 'Screenshot Max Width',
+        tooltip: 'Maximum width for screenshots. Images wider than this are downscaled. 0 = no limit.'
+    })
+    public screenshotMaxWidth = 960;
+
+    @property({
+        displayName: 'Screenshot JPEG Quality',
+        tooltip: 'Compression quality (1-100). Lower values are smaller files.'
+    })
+    public screenshotJpegQuality = 60;
+
+    @property({
+        displayName: 'Screenshot Interval (s)'
+    })
+    public screenshotIntervalSeconds = 2.0;
+
+    @property({
+        displayName: 'Screenshot Post Interval (s)'
+    })
+    public screenshotPostIntervalSeconds = 5.0;
+
+    @property({
+        displayName: 'Poll Results Interval (s)'
+    })
+    public pollResultsIntervalSeconds = 5.0;
+
+    @property({
+        displayName: 'Enable Debug Logging'
+    })
+    public enableDebugLogging = false;
+
+    public getConfig(): SkillprintConfig {
+        return {
+            gameName: this.gameName,
+            targetEnvironment: this.targetEnvironment,
+            productionPartnerApiKey: this.productionPartnerApiKey,
+            productionApiBaseUrl: this.productionApiBaseUrl,
+            stagingPartnerApiKey: this.stagingPartnerApiKey,
+            stagingApiBaseUrl: this.stagingApiBaseUrl,
+            screenshotMaxWidth: this.screenshotMaxWidth,
+            screenshotJpegQuality: this.screenshotJpegQuality,
+            screenshotIntervalSeconds: this.screenshotIntervalSeconds,
+            screenshotPostIntervalSeconds: this.screenshotPostIntervalSeconds,
+            pollResultsIntervalSeconds: this.pollResultsIntervalSeconds,
+            enableDebugLogging: this.enableDebugLogging,
+            gameParameters: []
+        };
+    }
+}