• commit the node_modules to the repo, or
• use @vercel/ncc to bundle everything into a single script.

I think both of these methods are not good practices. Especially, for my case, the way with @vercel/ncc is not feasible because some package uses require.

The best way to handle this is to make GitHub cache and install all the dependencies for the user every time the action is run. This can be made possible by creating a composite action. Here is a snippet in action.yml:

          
            runs:

              using: composite

              steps:

                - name: Setup Node.js

                  uses: actions/setup-node@v4

                  with:

                    node-version: '20'

            

                - name: Get cache key and path

                  id: lock

                  run: |

                    cd $GITHUB_ACTION_PATH

                    node <<'JAVASCRIPT'

                      const fs = require('fs');

                      const os = require('os');

                      const sha256 = require('crypto').createHash('sha256');

                      const hash = sha256.update(fs.readFileSync('package-lock.json')).digest('hex');

                      fs.appendFileSync(process.env.GITHUB_OUTPUT, `key=${os.platform()}-${os.arch()}-grs-modules-${hash}\n`);

                    JAVASCRIPT

                    modules=$(pwd)/node_modules

                    command -v cygpath &> /dev/null && modules=$(cygpath -w $modules)

                    echo "modules=$modules" >> $GITHUB_OUTPUT

                    cat $GITHUB_OUTPUT

                    cd $GITHUB_WORKSPACE

                  shell: bash

            

                - name: Restore cache

                  uses: actions/cache/restore@v4

                  id: cache-restore

                  with:

                    path: ${{ steps.lock.outputs.modules }}

                    key: ${{ steps.lock.outputs.key }}

            

                - name: CI

                  if: steps.cache-restore.outputs.cache-hit != 'true'

                  run: |

                    cd $GITHUB_ACTION_PATH

                    npm ci

                    cd $GITHUB_WORKSPACE

                  shell: bash

            

                - name: Save cache

                  if: steps.cache-restore.outputs.cache-hit != 'true'

                  uses: actions/cache/save@v4

                  with:

                    path: ${{ steps.lock.outputs.modules }}

                    key: ${{ steps.lock.outputs.key }}

            

                - name: Run

                  run: node $GITHUB_ACTION_PATH/index.js

                  shell: bash

          
        

I manually use actions/cache to cache the node_modules directory although actions/setup-node has caching functionality. This is because it is not good yet. Also, because github.action_path ends with /./, it can cause some problem due to the relative pathing. My workflow here works around those problems.

The hash in the cache key is calculated using JavaScript because there is no sha256sum command on macOS and Ubuntu runners.

If you visit the page I have just created, you may find the simulation of a mechanical system.

It is currently $$\mathcal H=p_1^2+p_2^2-\cos q_1-\cos q_2- \cos\!\left(q_1-q_2\right)$$ depicting two pendulum coupled with a spring (with $l_1=l_2$ and $m_1=m_2$, and the original length of the spring is zero, and the two hanging points overlap),

which is a classical example of non-linearly coupled system.

The pattern of the oscillation can be analyzed using discrete Fourier transformation, whose result can be found by clicking the buttons in the up-left corner (after the simulator has detected a period).

Hitting the space bar can make the simulation pause.

If you want to use it to simulate other mechanical systems, you can study the codes I wrote and write your own codes in the console.

By the way, the OpenRGSS version of the simulator is open-source here. Please star the repo if you like it.

I only have experience in using RPG Maker XP, RPG Maker VX, RPG Maker VX Ace, and RPG Maker MV.

Games made by using RM are based on

In most cases, when I say RGSS, I mean RGSS, RGSS2, and RGSS3. RGSS is in Ruby and rpg_core.js is in Javascript.

The scripts of a basic RGSS game look like

          
            def start

            	# some codes

            end

            def update

            	# some codes

            end

            

            start

            loop do

            	update

            	Input.update

            	Graphics.update

            end

          
        

The scripts of a basic rpg_core.js game look like

          
            function start() {

            	// some codes

            }

            function update() {

            	// some codes

            }

            

            Graphics.initialize(816, 624, 'webgl');

            Graphics.boxWidth = 816;

            Graphics.boxHeight = 624;

            WebAudio.initialize(false);

            Input.initialize();

            TouchInput.initialize();

            var deltaTime = 1.0 / 60.0;

            var accumulator = 0.0;

            var currentTime;

            window.scene = new Stage();

            start();

            function performUpdate() {

            	Graphics.tickStart();

            	var newTime = performance.now();

            	if (currentTime === undefined) currentTime = newTime;

            	var fTime = ((newTime - currentTime) / 1000).clamp(0, 0.25);

            	currentTime = newTime;

            	accumulator += fTime;

            	while (accumulator >= deltaTime) {

            		Input.update();

            		TouchInput.update();

            		update();

            		accumulator -= deltaTime;

            	}

            	Graphics.render(window.scene);

            	requestAnimationFrame(performUpdate);

            	Graphics.tickEnd();

            }

            performUpdate();

          
        

There is a simple rpg_core.js game written by me which can be accessed here. You can look at its source code by using your browser.

RM also provides a lot of scripts serving as making RPG. There is a simple RPG built by me which can be accessed here.

The source codes of RGSS are secret, but those of rpg_core.js are not a secret and can be seen at its GitHub repo.