Halloween Challenge

It’s the weekend and you’ve just completed a seance with friends. After communing with the dead, you realize a mysterious message was left behind.

3🍬4🎃04🎃6👻00🎃62🎃6👻32👻5🎃4🍬42🎃4🎃2🎃6🍬3🎃52🍬3🎃6💀0🎃2🎃6🍬13🍬0🎃432👻4👻4🎃230🎃62🎃1🍬03🎃2🍬6 🍬4👻5👻3🎃220🎃5👻0👻5🎃4🎃6👻42🎃4👻01🎃60🍬1🎃2👻3👻30🎃6💀0👻0🍬3🎃5👻0👻5🎃6👻0🍬30🎃61🍬0🎃1🎃2🎃6🎃42👻3🍬03🎃2💀3 🎃0🎃2👻5🎃22🍬3🎃5🎃6🍬3🎃5🎃2🎃6🎃52🍬4👻5🍬3🎃2🎃1🎃6👻4🍬0🍬0👻5🍬6🎃6👻0🍬30🎃604👻5🍬32💀1🎃6💀0🎃2🎃6🎃2💀1🍬1👻3🍬03🎃2🍬6 4🎃2🍬3🎃6👻0👻5🎃6🍬3🎃5🎃2🎃6💀0🍬03👻3🎃1🎃6🍬0🎃3🎃6🍬13🍬0🎃432👻4👻4👻0👻5🎃4🍬6🎃6👻0🍬3🎃6🍬3🎃53👻0🍬5🎃20🎃6🎃2🍬5🎃2👻5🎃6👻4🍬03🎃2💀3 👻0👻5🎃6🍬3🎃5🎃2🎃6134🍬1🍬3👻01🎃6👻4🎃2🍬3🎃5🍬0🎃10🍬6🎃6💀0🎃5🎃23🎃2🎃6🎃2🎃23👻0🎃2🎃6🎃0🍬4🎃40🎃6👻424🎃6🍬33🎃22🎃1🍬6 0👻2🎃2👻3🎃2🍬3🍬0👻50🎃6🍬0🎃3🎃6🎃233🍬030🎃6👻0👻5🎃6🍬3🎃5🎃2🎃6🎃123👻2🎃623🎃2🎃6💀0👻0🎃1🎃20🍬13🎃22🎃1💀3 👻5🍬0🍬3🎃62🎃6👻32👻5🎃4🍬42🎃4🎃2🎃6🍬0🎃3🎃6🍬3🎃5🎃2🎃6🍬120🍬3🍬6🎃6🎃0🍬4🍬3🎃6🍬0👻5🎃2🎃6💀0🎃2🎃6🎃5🍬0👻3🎃1🎃6🍬0🍬43🎃6🎃5🎃22🎃10🍬6 🍬0🍬5🎃23🎃61🍬0🍬4👻5🍬3👻3🎃200🎃6🍬13🍬0👻1🎃21🍬30🍬6🎃6💀0🎃5🎃23🎃2🎃6👻0🍬30🎃6🍬1🍬0💀0🎃23🎃6🎃520🎃60🍬13🎃22🎃1💀3 🍬3🎃5🎃2🎃6🍬33👻01👻20🎃62👻5🎃1🎃6🍬33🎃22🍬30🎃6🍬0🎃3🎃63🍬4🎃04🍬6🎃6👻3👻0👻2🎃2🎃6💀0👻0🍬31🎃5🎃20👻6🎃61🎃523👻40🍬6🎃61🍬0👻5🍬5🎃2👻5🎃2🍬6 🎃132💀0👻0👻5🎃4🎃6🍬40🎃6👻0👻5🍬3🍬0🎃6👻0🍬30🎃6💀0🍬03👻3🎃1🍬6🎃6💀0🎃5🎃23🎃2🎃6🍬3🎃5🎃2🎃60🍬4🎃0👻3👻0👻4🎃2🎃6👻00🎃60🎃2🎃2👻5💀3 🎃2👻51🎃52👻5🍬3👻0👻5🎃4🎃6🍬40🎃6💀0👻0🍬3🎃5🎃6🎃4🎃2👻40🍬6🎃6👻0🍬3👻60🎃6🎃2🍬5🎃234🎃61🍬0🎃1🎃23👻60🎃6🎃13🎃22👻4🍬6 2🎃1🍬5🎃2👻5🍬3🍬43🎃20🎃6👻0👻5🎃6🍬3🎃5🎃2🎃61🍬0🎃1🎃2🍬6🎃6💀0🎃5🎃23🎃2🎃6🍬3🎃5🎃2🎃6🎃2🎃23👻0🎃2👻60🎃63🍬0🍬4🍬3👻0👻5🎃2💀3 🎃1🎃22🍬3🎃5🎃6👻424🎃60🎃2🎃2👻4🎃6🍬3🍬0🎃6👻3🍬43👻2🍬6🎃6🎃0🍬4🍬3🎃6🎃3🍬03🎃63🍬4🎃04🎃6👻0🍬3👻60🎃6🎃52👻3👻3🍬0💀0🎃2🎃2👻56

However, with your unique Ouija board you should have no problem deciphering what they left!

Objective

Your Ouija board looks like the following straddling checkerboard:

================================== | | 0 | 1 | 2 | 3 | 4 | 5 | 6 | | | S | C | A | R | Y | ? | ! | | 🎃 | B | D | E | F | G | H | | | 👻 | I | J | K | L | M | N | ' | | 🍬 | O | P | Q | T | U | V | , | | 💀 | W | X | Z | . | # | $ | : | ==================================

Use your Ruby skills and the board above to decrypt the message. I have attached a file to help get you started. You don’t need to use it if you don’t want to.

You may also find this link helpful too.

Requirements

• Must use Ruby
• Decrypt the message
• Determine the hidden message within the decrypted message

My solution

I am too stupid to think of regular expressions at first, so I wrote this:

          
            " 0123456\n SCARY?!\n🎃BDEFGH \n👻IJKLMN'\n🍬OPQTUV,\n💀WXZ.\#$:".split(?\n).map(&:chars).tap{|b|<<M.chars.reduce(nil){|r,e|e==?\n?print(e): r ?print(b[r][b[0].index e]): b.index{_1[0]==e}||print(b[1][b[0].index e])}}

            3🍬4🎃04...

            M

          
        

I did not want to code golf, but I did intend to wrote a one-liner. It seems hard to understand, but it is pretty straightforward if it is expanded:

          
            board = [' ', '0', '1', '2', '3', '4', '5', '6'],

                    [' ', 'S', 'C', 'A', 'R', 'Y', '?', '!'],

                    ['🎃', 'B', 'D', 'E', 'F', 'G', 'H', ' '],

                    ['👻', 'I', 'J', 'K', 'L', 'M', 'N', "'"],

                    ['🍬', 'O', 'P', 'Q', 'T', 'U', 'V', ','],

                    ['💀', 'W', 'X', 'Z', '.', '#', '$', ':']

            message = <<MESSAGE

            3🍬4🎃04...

            MESSAGE

            

            message.chars.reduce nil do |row, encoded_char|

            	if encoded_char == ?\n # newline in the message

            		print encoded_char

            	elsif row # last char is an emoji, corresponding to a row in the board

            		print board[row][board[0].index encoded_char]

            		nil

            	elsif new_row = board.index { _1[0] == encoded_char }

            		new_row

            	else

            		print board[1][board[0].index encoded_char]

            		nil

            	end

            end

          
        

Then, I realized that I could have used regular expressions, so I wrote a cleaner version:

          
            puts <<M.gsub(/([🎃👻🍬💀])?([0-6])/){|s|{nil=>'SCARY?!',🎃:'BDEFGH ',👻:"IJKLMN'",🍬:'OPQTUV,',💀:'WXZ.#$:'}[$1&.to_sym][$2.to_i]}

            3🍬4🎃04...

            M

          
        

Then, I suddenly become creative and realized that I can use another regular expression to implement a string-based indexing, and that I can use -p option of Ruby command line to save even more characters (here I smelled code golfing):

          
            #!/usr/bin/env ruby -p

            gsub(/(\D?)(\d)/){'SCARY?!🎃BDEFGH 👻IJKLMN\'🍬OPQTUV,💀WXZ.#$:'[/#$1.{#$2}(.)/,1]}

          
        

Here are some other solutions. Check them out!

Some explanations for the code golf solution

• The -p option basically wraps the code in a while gets loop, and you can access the current line with $_. Ruby will output the contents of $_ after each iteration.
• The method Kernel#gsub modifies $_ (the current processing input line). It is only available when running Ruby with -p option.
• The method String#[] returns a substring. What is good about this method is that, if you use a regular expression to find the substring, you can use the second argument to specify which capture group in the regular expression you want to return.
• In a string literal, you can use #$some_global_variable as a shortcut of #{$some_global_variable}. This is also true for instance variables and class variables.

The message

The decoded message is:^©

          
            RUBY IS A LANGUAGE THAT WE PROGRAMMERS ADORE,

            UNLEASHING MAGIC SPELLS WITHIN ITS CODE GALORE.

            BENEATH THE HAUNTED MOON, ITS SYNTAX WE EXPLORE,

            YET IN THE WORLD OF PROGRAMMING, IT THRIVES EVEN MORE.

            

            IN THE CRYPTIC METHODS, WHERE EERIE BUGS MAY TREAD,

            SKELETONS OF ERRORS IN THE DARK ARE WIDESPREAD.

            

            NOT A LANGUAGE OF THE PAST, BUT ONE WE HOLD OUR HEADS,

            OVER COUNTLESS PROJECTS, WHERE ITS POWER HAS SPREAD.

            THE TRICKS AND TREATS OF RUBY, LIKE WITCHES' CHARMS, CONVENE,

            

            DRAWING US INTO ITS WORLD, WHERE THE SUBLIME IS SEEN.

            ENCHANTING US WITH GEMS, IT'S EVERY CODER'S DREAM,

            ADVENTURES IN THE CODE, WHERE THE EERIE'S ROUTINE.

            DEATH MAY SEEM TO LURK, BUT FOR RUBY IT'S HALLOWEEN!

          
        

Did you spot the hidden message?

If there are 200 typographical errors randomly distributed in a 500 page manuscript, find the probability that a given page contains exactly 3 errors.

We can abstract this type of problems as follows:

Suppose there are $n$ distinguishable boxes and $k$ indistinguishable balls. Now, we randomly put the balls into the boxes. For each of the boxes, what is the probability that it contains $m$ balls?

For example, if the first page contains 3 errors, the second page contains 197 errors, and the rest of the pages contain no errors, then the situation corresponds to the situation where the first box contains 3 balls, the second box contains 197 balls, and the rest of the boxes contain no balls. The balls are indistinguishable because we can only determine how many errors are on each page but not which errors are on the page.

To deal with the problem, we simply need to find these two numbers:

• the number of ways to put $k$ indistinguishable balls into $n$ distinguishable boxes, and
• the number of ways to put $k-m$ indistinguishable balls into $n-1$ distinguishable boxes.

The latter corresponds to the number of ways to put the balls into the boxes provided that we already know that the given box contains $m$ balls. After we find these two numbers, their ratio is the probability in question.

To find the number of ways to put $k$ indistinguishable balls into $n$ distinguishable boxes, we can use the stars and bars method. To see this, we write a special example. Here is an example of $n=4$ and $k=6$: $${}|{}\star{}\star{}|{}\star{}|{}\star{}\star{}\star{},$$ which corresponds to the distribution $0,2,1,3$. We can see that there are $n-1$ bars and $k$ stars. Therefore, the number of ways to put the balls is the same as the number of ways to choose the $k$ positions of the stars among $n+k-1$ positions. Therefore, the number of ways is $$N_{n,k}=\binom{n+k-1}{k}=\frac{\left(n+k-1\right)!}{k!\left(n-1\right)!}.$$ Therefore, the final probability of the given box containing $m$ balls is $$P_{n,k}(m)=\frac{N_{n-1,k-m}}{N_{n,k}} =\frac{\left(n-1\right)k!\left(n+k-m-2\right)!}{\left(k-m\right)!\left(n+k-1\right)!}.$$

Another easy way to derive this result is by using the generating function. The number $N_{n,k}$ is just the coefficient of $x^k$ in the expansion of the generating function $\left(1+x+x^2+\cdots\right)^n$. The generating function is just $\left(1-x\right)^{-n}$, which can be easily expanded by using the binomial theorem.

We are now interested in the limit $n,k\to\infty$ with $\lambda\coloneqq k/n$ fixed. By Stirling’s approximation, we have $$P_{n,k}(m)\sim\left(n-1\right) \frac{k^{k+1/2}\left(n+k-m-2\right)^{n+k-m-2+1/2}}{\left(k-m\right)^{k-m+1/2}\left(n+k-1\right)^{n+k-1+1/2} } \mathrm e^{k-m+n+k-1-k-n-k+m+2}.$$ The $1/2$’s in the exponents can just be dropped because you may find that if we extract the $1/2$’s, the factor tends to unity. The exponential is just constant $\mathrm e$. Therefore, we have $$\begin{align*} P_{n,k}(m)&\sim\left(n-1\right) \frac{\left(\lambda n\right)^{\lambda n}\left(n+\lambda n-m-2\right)^{n+\lambda n-m-2} } {\left(\lambda n-m\right)^{\lambda n-m}\left(n+\lambda n-1\right)^{n+\lambda n-1}}\mathrm e\\ &=\left(\tfrac{n+\lambda n-m-2}{n+\lambda n-1}\right)^n \left(\tfrac{\left(n+\lambda n-m-2\right)\lambda n}{\left(\lambda n-m\right)\left(n+\lambda n-1\right)}\right)^{\lambda n} \left(\tfrac{\lambda n-m}{n+\lambda n-m-2}\right)^m \tfrac{\left(n-1\right)\left(n+\lambda n-1\right)}{\left(n+\lambda n-m-2\right)^2}\mathrm e\\ &\to\mathrm e^{-\frac{m+1}{\lambda+1}}\,\mathrm e^m\, \mathrm e^{-\frac{m+1}{\lambda+1}\lambda}\left(\tfrac\lambda{\lambda+1}\right)^m\tfrac1{\lambda+1}\mathrm e\\ &=\left(\tfrac\lambda{\lambda+1}\right)^m\tfrac1{\lambda+1}. \end{align*}$$ This is just the geometric distribution with parameter $p=1/(\lambda+1)=n/(k+n)$.

If you want to simulate the number of balls in a box, here is a simple way to do this. First, because each box is the same, we can just focus on the first box without loss of generality. Then, we just need to randomly generate the positions of the $n-1$ bars among the $n+k-1$ positions, and then return the index of the first bar (which is the number of balls in the first box).

We can then write the following Ruby code to simulate the number of balls in the first box:

          
            def simulate n, k

              (n-1).times.inject(npkm1 = n+k-1) { |bar, i| [rand(npkm1 - i), bar].min }

            end

          
        

Compare the simulated result with the theoretical result:

          
            def frequency m, n, k, trials

              trials.times.count { simulate(n, k) == m } / trials.to_f

            end

            

            def truth m, n, k

              (n-1) * (k-m+1..k).reduce(1,:*) / (n+k-m-1..n+k-1).reduce(1,:*).to_f

            end

            

            def approx m, n, k

              n*k**m / ((n+k)**(m+1)).to_f

            end

            

            srand 1108

            m, n, k = 3, 5000, 8000

            p frequency m, n, k, 10000 # => 0.0902

            p truth m, n, k # => 0.08965012972626446

            p approx m, n, k # => 0.08963271594131858

          
        

• Some languages can name loops by providing a label for the loop. In those languages, you can use break together with a label to specify which loop to break out of. Examples: Perl, Java, JavaScript, and some others.
• Some languages can specify the number of layers of loops to break out of. In those languages, you can use break together with a number to specify how many layers of loops to break out of. The only example that I know is C#.
• Some languages have goto statements. You can easily break from loops to wherever you want by using goto (actually breaking out of nested loops is among the only recommended cases for using goto). Examples: C, C++.

However, in most other languages, it is not easy to break out of nested loops. A typical solution is this:

          
            outer_loop do

            	break_outer = false

            	inner_loop do

            		if condition

            			break_outer = true

            			break

            		end

            	end

            	break if break_outer

            end

          
        

In languages with exceptions, another possible workaround is to use exceptions (the catch–throw control flow):

          
            catch :outer_loop do

            	outer_loop do

            		inner_loop do

            			throw :outer_loop if condition

            		end

            	end

            end

          
        

I wrote a simple module to better use this workaround.

          
            class JumpLabel < StandardError

            	attr_reader :reason, :arg

            	{break: true, next: true, redo: false}.each do |reason, has_args|

            		define_method reason do |*args|

            			@reason = reason

            			@arg = args.size == 1 ? args.first : args if has_args

            			raise self

            		end

            	end

            end

            

            class Module

            	def register_label *method_names

            		method_names.each do |name|

            			old = instance_method name

            			define_method name do |*args, **opts, &block|

            				return old.bind_call self, *args, **opts unless block

            				old.bind_call self, *args, **opts do |*bargs, **bopts, &bblock|

            					block.call *bargs, **bopts, jump_label: label = JumpLabel.new, &bblock

            				rescue JumpLabel => catched_label

            					raise catched_label unless catched_label == label

            					case label.reason

            					when :break then break label.arg

            					when :next then next label.arg

            					when :redo then redo

            					end

            				end

            			end

            		end

            	end

            end

          
        

Example usage:

          
            Integer.register_label :upto, :downto

            1.upto 520 do |i, jump_label:|

            	print i

            	1.downto -1314 do |j|

            		print j

            		jump_label.break 8 if j == 0

            	end

            end.tap { puts _1 }

            # => 1108

          
        

I may use calendar apps to help me with that, but there is a problem around it: most calendar apps set periodical events based on weeks (i.e. you can set an event to happen on every Monday but can not set it to happen every other day). Since my need is actually very easy to satisfy (I just need a reliable reminder!), I decided to write a Ruby program to help me with that.

The program is called peroutine. It is available on GitHub. It is a Ruby program that runs on the command line. I can now see whether I need to wash my hair or clothes today by running peroutine list! It also notifies me every day at 11 PM via my self-hosted ntfy server whether I need to wash my hair today.

Emails normally have two types of message body: plain text and HTML. Plain text is just plain text, we do not expect it to have any typesetting ability itself. However, HTML is a much more capable content type.

In theory, we should be able to ask the HTML renderer to typeset math by using <math> elements (MathML). However, modern browsers generally do not support them by default. As for today (when this post is created), the only modern browsers that support MathML without modifications are Firefox and Safari. Chrome, Edge, and Opera support MathML only when the #enable-experimental-web-platform-features preferences are set to Enabled. Supporting for MathML is even worse if we are considering mobile browsers or email clients. Therefore, MathML should not be our first choice although it could have been the most elegant way.

The next choice is to use <img> or <svg> elements. There are two ways of doing this: host a server that has API to convert math to images; or, write a program to generate the email with all images generated (as image data URLs or <svg> elements) as well (actually I have already found a solution for such programs: mathematical). The first way have the following disadvantages:

• It requires me to either use some third-party service (like CODECOGS Equation Renderer) or maintain a public server which would be exposed to my email receivers.
• It is hard for me make the position of the baseline of rendered math correctly.
• Email clients will probably block images from remote sources.

Both ways have the following disadvantages:

• There is no “half-working”—either the math is rendered, or it cannot be read at all (on email clients that do not support or block <img> or <svg> elements).
• Math expressions cannot have line breaks in the middle.
• Images normally have a larger bandwidth burden.
• It is hard to get them aware of the context (text size, color, etc.).

Therefore, I try to seek other ways.

You may wonder how I typeset math in my blog. The answer is that I use MathJax. To integrate it on a webpage, I just load a JavaScript script to the webpage, and it will convert all the $\TeX$ expressions to math. Although we normally cannot have JavaScript in emails, this is actually also a good candidate for typesetting math in emails because I can use its Node.js module to generate the email with math typeset. The generated email already has all the math rendered, and there is no client-side JavaScript needed.

However, before using Node.js to write my program of generating email, I looked into KaTeX. How KaTeX advertise itself is saying that it is the fastest math typesetting library for the web. Well, actually I do not care about the speed of typesetting, but there is something about KaTeX that I found interesting: kramdown-math-katex, which implements for us the conversion from Markdown to HTML with math typeset. I am familiar with Ruby and prefer a Ruby project to a Node.js project, so this looks amazing to me. What is more amazing is that I can combine it with Jekyll to create even more possibility about how I can generate my email.

Then, I implemented my idea and finally created this. I have already used it to generate some emails (such as this one). I then just paste the generated HTML into the HTML editor of my email client (Thunderbird, with this add-on).

By generating the email, the email receivers can see the math typeset without running any JavaScript on their clients. However, they need their email client to support CSS styling (Thunderbird does). I need to inform the receiver of this every time I send an email containing math.

To utilize the canonical equations $$\frac{\mathrm d\mathbf q}{\mathrm dt}= \frac{\partial\mathcal H}{\partial\mathbf p},\quad \frac{\mathrm d\mathbf p}{\mathrm dt}= -\frac{\partial\mathcal H}{\partial\mathbf p},$$ $$(1)$$ we need to calculate the partial derivatives of $\mathcal H$. Here is a simple code to calculate partial derivatives.

          
            def div x0, dx, f

            	f0 = f.(x0)

            	n = x0.size

            	Array.new n do |i|

            		(f.(x0 + Vector.basis(n, i) * dx) - f0) / dx

            	end

            end

          
        

(RGSS do not have matrix.rb, you can copy one from the attached file below.) Here x0 is a Vector, f is a call-able object as a function of vectors, dx is a small scalar which we are going to take 1e-6.

Let x = Vector[*q, *p], and then Formula 1 has the form $$\frac{\mathrm d\mathbf x}{\mathrm dt}=f\!\left(\mathbf x\right).$$ To solve this equation numerically, we need to use a famous method called the (explicit) Runge–Kutta method.

          
            def runge_kutta initial, max_t, dt, (*pyramid, coefs), func

            	(0..max_t).step(dt).reduce initial do |ret, t|

            		$canvas.trace t, ret if $canvas

            		coefs.zip(pyramid).each_with_object([]).sum do |(coef, row), ary|

            			coef * ary.push(func.(t, row.inner(ary) * dt + ret)).last

            		end * dt + ret#p(ret)

            	end

            end

          
        

Note that Runge–Kutta is a family of methods. The argument (*pyramid, coefs) takes one of the following, each of which is a single Runge–Kutta method.

          
            FORWARD_EULER = [[],[1]]

            EXPLICIT_MIDPOINT = [[],[1/2.0],[0,1]]

            HEUN = [[],[1],[1/2.0,1/2.0]]

            RALSTON = [[],[2/3.0],[1/4.0,3/4.0]]

            KUTTA_3RD = [[],[1/2.0],[-1,2],[1/6.0,2/3.0,1/6.0]]

            HEUN_3RD = [[],[1/3.0],[0,2/3.0],[1/4.0,0,3/4.0]]

            RALSTON_3RD = [[],[1/2.0],[0,3/4.0],[2/9.0,1/3.0,4/9.0]]

            SSPRK3 = [[],[1],[1/4.0,1/4.0],[1/6.0,1/6.0,2/3.0]]

            CLASSIC_4TH = [[],[1/2.0],[0,1/2.0],[0,0,1],[1/6.0,1/3.0,1/3.0,1/6.0]]

            RALSTON_4TH = [[],[0.4],[0.29697761,0.15875964],[0.21810040,-3.05096516,

            		3.83286476],[0.17476028, -0.55148066, 1.20553560, 0.17118478]]

            THREE_EIGHTH_4TH = [[],[1/3.0],[-1/3.0,1],[1,-1,1],[1/8.0,3/8.0,3/8.0,1/8.0]]

          
        

Here we are going to take CLASSIC_4TH.

The $canvas appearing here is an object that is going to draw the result onto the screen.

Here we also need to have some patches to get it work.

          
            class Float

            	alias ulysses20200426121236_add +

            	def + other

            		if zero? && [Vector, Matrix].any? { |c| other.is_a? c }

            			other

            		else

            			ulysses20200426121236_add other

            		end

            	end

            end

            module Enumerable

            	def sum init = 0, &block

            		(block ? map(&block) : self).reduce init, :+

            	end

            end

            class Array

            	def inner other

            		zip(other).sum { |a, b| a * b }

            	end

            end

          
        

(Again, note that this is Ruby 1.9.2.)

Finally, just combine them up, and we can solve a Hamiltonian numerically.

          
            def solve_hamiltonian n, qp0, max_t, dt, hamiltonian

            	runge_kutta qp0, max_t, dt, CLASSIC_4TH, ->t, qp do

            		dqpdt = div qp, 1e-6, ->x { hamiltonian.(t, x) }

            		Vector[*dqpdt[n...n*2], *dqpdt[0...n].map(&:-@)]

            	end

            end

          
        

For example, let’s simulate a double pendulum.

          
            solve_hamiltonian 2,Vector[PI/2,0.0,0.0,0.0],Float::INFINITY,1e-3,

            		->t,(q1,q2,p1,p2){p1**2+p2**2/2+cos(q1-q2)*p1*p2-cos(q1)-cos(q2)}

          
        

The codes are not complete in this post. See the attached file for details. You can open the project using RPG Maker VX Ace. The Game.exe file is not the official Game.exe executable but the third-party improved version of it called RGD (of version 1.3.2, while the latest till now is 1.5.1).

          
            Robot.new do

            	a b c

            	d e

            	f g h i

            	j

            end.run

          
        

outputs

          
            Go to a

            Go to b

            Go to c

            Go to d

            Go to e

            Go to f

            Go to g

            Go to h

            Go to i

            Go to j

          
        

Since separating by space means method invocation in Ruby, we need to hack into method_missing.

I am just posting the codes and will not give it further explanation. Look into the details yourself.

          
            class Robot

            	attr_accessor :movements

            	def initialize &block

            		@movements = []

            		@last_length = 0

            		instance_eval &block if block

            		rearrange

            	end

            	def method_missing name, *args

            		case args.size

            		when 0

            			rearrange

            			@movements.push result = Movement.new(name)

            			@last_length += 1

            			result

            		when 1

            			@movements.push result = Movement.new(name)

            			@last_length += 1

            			result

            		else

            			super

            		end

            	end

            	def rearrange

            		last_movements = @movements.last @last_length

            		@movements[@movements.size - @last_length..] = last_movements.reverse

            		@last_length = 0

            	end

            	def run

            		puts @movements

            	end

            	class Movement

            		attr_accessor :target

            		def initialize target

            			@target = target

            		end

            		def to_s

            			"Go to #@target"

            		end

            	end

            end

          
        

Similar tricks are used in my other Ruby project alda-rb. The codes can be found on GitHub.

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.

The original idea is to implement a method Module#def_after so that I can easily make something to be done after the original method. Like this:

          
            class Foo

            	def bar

            		print 'before'

            	end

            end

            

            class Foo

            	def_after :bar do

            		puts ' & after'

            	end

            end

            

            Foo.new.bar # => before & after

          
        

The implementation is a little easy:

          
            class Module

            	def def_after method_name, &refine_block

            		old = instance_method method_name

            		define_method method_name do |*args, **opts, &block|

            			old.bind_call self, *args, **opts, &block

            			refine_block.(*args, **opts, &block)

            		end

            	end

            end

          
        

However, there is a little problem. The self in refine_block depends on how and where refine_block is defined instead of just being the instance receiving the method.

Since an instance method (UnboundMethod object) defined in a Module can bind any other object, we can use Module#define_method and send refine_block as a block parameter, and then bind the instance method to self:

          
            class Proc

            	def bind receiver

            		Module.new.module_exec self do |block|

            			instance_method define_method :_, &block

            		end.bind receiver

            	end

            	def bind_call receiver, *args, **opts, &block

            		bind(receiver).(*args, **opts, &block)

            	end

            end

            class Module

            	def def_after method_name, &refine_block

            		old = instance_method method_name

            		define_method method_name do |*args, **opts, &block|

            			old.bind_call self, *args, **opts, &block

            			refine_block.bind_call self, *args, **opts, &block

            		end

            	end

            end

          
        

The self can successfully be converted. You can test it yourself.

Here is still a problem. When the new instance method is defined, its visibility is public, while the original visibility may be private or protected.

Use the following means to get the visibility beforehand and set the visibility afterward:

          
            class Module

            	def method_visibility method_name

            		%i[public protected private].find do |visibility|

            			__send__ :"#{visibility}_method_defined?", method_name

            		end

            	end

            	def def_after method_name, &refine_block

            		visibility = method_visibility method_name

            		old = instance_method method_name

            		define_method method_name do |*args, **opts, &block|

            			old.bind_call self, *args, **opts, &block

            			refine_block.bind_call self, *args, **opts, &block

            		end

            		__send__ visibility, method_name

            	end

            end

          
        

There can be some improvement. If we need to refine a singleton method, calling def_after on its singleton_class will lead to calling obj.singleton_class.instance_method(sym).bind_call(obj, *), which is way too complex. The straightforward way to do it is to call obj.method(sym).call(*).

With this inspiration, we can implement Object#def_after:

          
            class Object

            	def def_after method_name, &refine_block

            		visibility = singleton_class.method_visibility method_name

            		old = method method_name

            		define_singleton_method method_name do |*args, **opts, &block|

            			old.(*args, **opts, &block)

            			refine_block.bind_call self, *args, **opts, &block

            		end

            		singleton_class.__send__ visibility, method_name

            	end

            end

          
        

Then there comes a new problem. A Module also has singleton methods, while Module#def_after can only change its instance methods instead of its singleton methods. The way to solve this is to judge whether is_a? Module in Object#def_after, and add a keyword argument singleton:

          
            class Object

            	def def_after method_name, singleton: false, &refine_block

            		singleton ||= !is_a?(Module)

            		# mod: the module containing the old method

            		# get_method: the method to get the Method/UnboundMethod obj

            		# def_method: the method to define a new method

            		mod, get_method, def_method = singleton ?

            				[singleton_class, method(:method), method(:define_singleton_method)] :

            				[self, method(:instance_method), method(:define_method)]

            		# get visibility

            		visibility = mod.method_visibility method_name

            		# get old

            		old = get_method.(method_name)

            		# override

            		def_method.(method_name) do |*args, **opts, &block|

            			old = old.bind self unless old.is_a? Method

            			old.(*args, **opts, &block)

            			refine_block.bind_call *args, **opts, &block

            		end

            		# set visibility

            		mod.__send__ visibility, method_name

            	end

            end

          
        

What about parsing a callable object as an argument instead of through refine_block? Parsing a Symbol can also be useful. Like this:

          
            Object.def_after :display, :puts

          
        

Then Object#def_after will be a little complex:

          
            class Object

            	# pat: when refine_block is nil, it is used to represent a refinement

            	# singleton: force singleton when self is a Module

            	def def_after method_name, pat = nil , singleton: false, &refine_block

            		singleton ||= !is_a?(Module)

            		# mod: the module containing the old method

            		# get_method: the method to get the Method/UnboundMethod obj

            		# def_method: the method to define a new method

            		mod, get_method, def_method = singleton ?

            				[singleton_class, method(:method), method(:define_singleton_method)] :

            				[self, method(:instance_method), method(:define_method)]

            		# get visibility

            		visibility = mod.method_visibility method_name

            		# get pat

            		pat = refine_block || {

            			to_sym:  ->symbol { get_method.(symbol.to_sym) },

            			to_proc: :to_proc.to_proc,

            			call:    ->callable { callable.method :call }

            		}.each do |duck, out|

            			break out.(pat) if pat.respond_to? duck

            		end

            		# get old

            		old = get_method.(method_name)

            		# override

            		def_method.(method_name) do |*args, **opts, &block|

            			# bind old

            			old = old.bind self unless old.is_a? Method

            			# bind pat

            			pat = pat.bind self unless pat.is_a? Method

            			# call the new method

            			old.(*args, **opts, &block)

            			pat.(*args, **opts, &block)

            		end

            		# set visibility

            		mod.__send__ visibility, method_name

            	end

            end

          
        

We are still not satisfied. We need to define a lot of methods like def_after, such as def_before, def_if… Maybe we should define Object::def_ and use it like this:

          
            class Object

            	# use this binding to eval to avoid excessive local variables

            	def self.class_binding

            		binding

            	end

            	{

            		after:  'result = old.(*); pat.(*); result',

            		after!: 'old.(*); pat.(*)',

            		before: 'pat.(*); old.(*)',

            		with:   'pat.(old.(*), *)',

            		chain:  'pat.(old, *)',

            		and:    'old.(*) && pat.(*)',

            		or:     'old.(*) || pat.(*)',

            		if:     'pat.(*) && old.(*)',

            		unless: 'pat.(*) || old.(*)'

            	}.each do |sym, code|

            		str = "def_(:#{sym}) { |old, pat, *| #{code} }"

            		str.gsub! ?*, '*args, **opts, &block'

            		class_binding.eval str

            	end

            	singleton_class.undef_method :def_, :class_binding

            end

          
        

The main difficulty is to implement Object::def_. We can accomplish this just by editing the Object#def_after we defined before:

          
            class Object

            	# the method is going to be undefined soon

            	def self.def_ sym, &def_block

            		# pat: when refine_block is nil, it is used to represent a refinement

            		# singleton: force singleton when self is a Module

            		define_method :"def_#{sym}" do |method_name, pat = nil, singleton: false,

            		                                &refine_block|

            			singleton ||= !is_a?(Module)

            			# mod: the module containing the old method

            			# get_method: the method to get the Method/UnboundMethod obj

            			# def_method: the method to define a new method

            			mod, get_method, def_method = singleton ?

            					[singleton_class, method(:method), method(:define_singleton_method)] :

            					[self, method(:instance_method), method(:define_method)]

            			# get visibility

            			visibility = mod.method_visibility method_name

            			# get pat

            			pat = refine_block || {

            				to_sym:  ->symbol { get_method.(symbol.to_sym) },

            				to_proc: :to_proc.to_proc,

            				call:    ->callable { callable.method :call }

            			}.each do |duck, out|

            				break out.(pat) if pat.respond_to? duck

            			end

            			# get old

            			old = get_method.(method_name)

            			# override

            			def_method.(method_name) do |*args, **opts, &block|

            				# bind old

            				old = old.bind self unless old.is_a? Method

            				# bind pat

            				pat = pat.bind self unless pat.is_a? Method

            				# call the new method

            				def_block.(old, pat, *args, **opts, &block)

            			end

            			# set visibility

            			mod.__send__ visibility, method_name

            		end

            	end

            end

          
        

The final source code can be found here.

The reason why I do not use Module#refine and Module#using is that they currently have too much limitations and even bugs. I have already found as many as two bugs (#16107 and #16617). Although both of them have been fixed (or will be fixed), I cannot be sure that there will not be further and fatal bugs. I do not think these features are very reliable in recent Ruby versions.