Roblox (iOS)

This page contains notes for the game Roblox (iOS).

Version Archives#

Fixing up the .png files from IPA archives#

Please keep in mind that some files are compiled differently compared to others, which causes cgbi-to-png to work for one image, but for the other one only go-png-cgbi works. The weird formatting fixed by go-png-cgbi seems to only be used on App Icons and on some older files. None of the engine images seem to be effected.

cgbi-to-png#

Using the cgbi-to-png NodeJS package you can undo the Xcode png compression known as CgBI. To use this library, you can follow these instructions or the one located below the script. To use this library you can install NodeJS and the cgbi-to-png package as instructed on the npmjs website. Then make a new file and give it a .js extension. Then paste in the following code and use the node command line to run it using for example the command node script.js. Please keep in mind that it will try to convert all .png files in the directory that's opened in the Command Shell/Prompt your using. This tool is used for CgBI png files that are a single file. When you have two images where one seems to be blank and the other is weirdly coloured and has an @2 in the filename then use the go-png-cgbi tool.

var fs = require('fs');
var path = require('path');
var cgbiToPng = require('cgbi-to-png');

const currentDirectory = '.'; // Represents the current directory
const originalFileBackupSuffix = '_original_backup'; // Suffix for the temporary backup of the original file

fs.readdir(currentDirectory, (err, files) => {
    if (err) {
        console.error('Error reading directory:', err);
        process.exit(1);
    }

    const pngFiles = files.filter(file => path.extname(file).toLowerCase() === '.png');

    if (pngFiles.length === 0) {
        console.log('No PNG files found in the current directory.');
        return;
    }

    console.log(`Found ${pngFiles.length} PNG file(s) in the current directory.`);

    pngFiles.forEach(inputFileName => {
        const originalFilePath = path.join(currentDirectory, inputFileName);
        const backupOriginalFilePath = path.join(currentDirectory, path.basename(inputFileName, '.png') + originalFileBackupSuffix + '.png');
        // The output file will take the original filename
        const outputFilePath = originalFilePath;

        // Skip if the file is already our temporary backup (to prevent infinite loops)
        if (inputFileName.endsWith(originalFileBackupSuffix + '.png')) {
            console.log(`Skipping temporary backup file: ${inputFileName}`);
            return;
        }

        try {
            // Step 1: Read the original file
            var cgbiBuffer = fs.readFileSync(originalFilePath);
            console.log(`\nProcessing file: ${inputFileName}. Size: ${cgbiBuffer.length} bytes.`);

            const cgbiSignature = Buffer.from('CgBI');
            const hasCgBI = cgbiBuffer.indexOf(cgbiSignature) !== -1;

            if (hasCgBI) {
                console.log("  Detected 'CgBI' signature. This file appears to be Xcode-compressed.");
            } else {
                console.log("  Did NOT detect 'CgBI' signature. It might already be a standard PNG or compressed differently.");
                console.log("  Attempting to revert anyway, but don't expect changes if it's already standard.");
            }

            // Step 2: Perform the conversion
            var pngBuffer = cgbiToPng.revert(cgbiBuffer);

            // Check if any actual conversion happened
            const didChange = Buffer.compare(cgbiBuffer, pngBuffer) !== 0;

            if (didChange) {
                console.log("  Output buffer is DIFFERENT from input buffer. Changes were applied.");
            } else {
                console.log("  Output buffer is IDENTICAL to input buffer. No changes were applied.");
                if (hasCgBI) {
                    console.log("  This is unexpected given the CgBI signature was found. There might be an issue with the library or the file's specific CgBI format.");
                } else {
                    console.log("  This is expected, as no CgBI signature was found. The file was likely already a standard PNG.");
                }
                // If no changes, you might not want to touch the file at all.
                // In this specific request, we still want to ensure only one file remains,
                // so we proceed to rename/delete steps even if content is identical.
            }

            // Step 3: Rename the original file to a temporary backup
            fs.renameSync(originalFilePath, backupOriginalFilePath);
            console.log(`  Original file temporarily backed up as '${path.basename(backupOriginalFilePath)}'.`);

            // Step 4: Write the converted buffer to the original filename
            fs.writeFileSync(outputFilePath, pngBuffer);
            console.log(`  Successfully saved converted file to '${path.basename(outputFilePath)}' (original name).`);

            // Step 5: Delete the temporary backup of the original file
            fs.unlinkSync(backupOriginalFilePath);
            console.log(`  Temporary backup '${path.basename(backupOriginalFilePath)}' deleted.`);
            console.log(`  Process completed for ${inputFileName}. Only the converted file remains.`);

        } catch (error) {
            console.error(`  An error occurred during conversion of '${inputFileName}':`);
            if (error.code === 'ENOENT') {
                console.error(`  Error: File not found during processing. This might happen if the file was moved or deleted unexpectedly.`);
            } else if (error.message.includes('Invalid PNG buffer')) {
                console.error('  The input file might be corrupted or not a valid PNG.');
            } else {
                console.error('  ', error.message);
            }
            // IMPORTANT: If an error occurs after renaming but before writing/deleting,
            // the `_original_backup.png` might be left behind. This is a trade-off for safety.
            console.warn(`  Warning: Due to the error, '${path.basename(backupOriginalFilePath)}' might still exist if the process failed midway.`);
        }
    });
});
// Yes, this code is A.I. generated. I couldn't be bothered to learn JS for this... --ThijsDeGamer

This method was used for Roblox_iOS-IOS-icon-App-Store.png.

Here's a step-by-step overview on how to use this tool.

• Go to nodejs.org and download the right release for your system using the buttons near the bottom listed as prebuilt.
• Follow the Node.js installer, the extra's aren't needed, but are recommended.
• Run the following command in a command terminal: (doing this in the user folder or your own directory is recommended) npm i cgbi-to-png.
• Copy the code listed above and paste it into a new text file.
• Change the files extension to .js, if you want to copy the rest of the commands without having to modify them, call the file script.js.
• Open a command terminal in the same folder the .js file is located at. (You can use cd for this.)
• Use the following command: node script.js, this will convert all .png files that are detected as CgBI to normal .png files.

go-png-cgbi#

This second method uses go-png-cgbi to convert files. This method is used for CgBI png's that are spread out over two files. You can recognize these files by the fact there are two .png files with the same name, other than the fact one of them has @2 in its name. For example: "roblox.png" and "roblox@2.png". Here's a step-by-step overview on how to use this tool.

• Go to go.dev and download the right file for your system.
• Run the downloaded file and follow the installer.
• Copy the code listed below and put it in a text file.
• Rename the text file to something like main.go. (Only the .go has to 100% be there!)
• Put the two images you want to convert into the same directory as main.go.
• Call one of the .png files "1" and the other one "2".
• Open a new command terminal inside of the same directory as main.go.
• Run the command: go run main.go

This method was used for Roblox_iOS-Default-568h@2x.png.

Notes#

• If there is only one @2 file, then duplicate the png and follow the normal steps. So you should end up with two identical files, one called "1" and another one with the name "2".