Introduction

I recently replayed through the Battle Frontier in Pokémon Emerald for the Ribbon Master Challenge, where you take a Pokémon through all the games they can be transferred into and earn all the available ribbons along the way. You could capture a Pokémon in any game from Ruby & Sapphire to Scarlet & Violet: the only requirement for the title of Ribbon Master is said Pokémon obtaining all Ribbons (and now Marks) they can in the games it can visit. Marks are an extension of Ribbons. Most are earned randomly when a Pokémon is captured, but at least a few can be obtained by fulfilling certain conditions. See 10 for a list.

This time, I decided to take my Arcanine from Pokémon XD through the challenge, and one of its first stops was the Battle Tower in the Battle Frontier. I got through both modes (Level 50 and Open Level) with no major difficulties, but one thing I noticed is that I haven’t earned the Gold Symbols on my physical cartridge; I only played through the Frontier facilities on an emulator. So I took a detour to make this right.

After losing 2 runs to bad luck and no planning in the Battle Pike, I started searching for suggestions on how to approach it. I found a post on Reddit with a lot of information on winning strategies, which helped me have an easier time and eventually earn the Gold Symbol, but most interestingly made me realize three things:

1. The state of your team affects the distribution of possible outcomes each round, i.e., what you see in each room depend on the health (also PPs used and presence of status effects) of your Pokémon.
2. Furthermore, the risk of each option also depends on the state of your team and how many rounds are left in the challenge. You can take more battles if your team is healthy, or gamble for recovery if you’re almost defeated.
3. Thus, the Battle Pike can be understood as a problem of Decision Under Uncertainty, with a corresponding solution in the form of a Decision Table.

Next up I review the mechanics of the Battle Pike before discussing why it’s a problem of this sort.

Battle Pike Mechanics

The Battle Pike is a facility located in the Battle Frontier themed around “luck”. Each round consists of two rooms: in the first one, you choose one out of three exits, after which you are faced with a randomly selected challenge (listed below). You win if you manage to survive 7 rounds without your whole team fainting.

But choosing a room at random would be boring, and that’s why an NPC stationed at each first room predicts what is behind one of the 3 exits. She will specify a door and tell you one of 4 quotes, corresponding to 2 possible challenges. The other unspecified doors can contain any of the other challenges.

The following table describes each quotes and their associated challenges:

In addition, the state of your team make some of the outcomes impossible. We could review the source code of the game to verify if that’s really what happens. I might do that eventually. The original Reddit post gives some evidence for that and my personal experience is similar. Some of these situations are as follows:

• If your whole team is afflicted by status (paralyzed, sleeping, burned, or frozen), then a Kirlia or Dusclops cannot show up. Option A will be One or two recovery.
• If your team is in perfect condition (full HP, no PPs used, no status), then there won’t be any form of recovery. So option A will be Status Condition, option B will be Single Battle, and option C will be Wild Pokémon.
• If you have only one Pokémon left, then you cannot play a double battle. Option D will be No Event.

You team consists of only 3 Pokémon for the challenge and there is no auto-healing between rounds, different from facilities like the Battle Tower and the Battle Factory. This is the reason random Status Conditions from option A can be a problem: some of your Pokémon will be left sleeping, paralyzed, or frozen and there’s not much you can do outside of hoping for a healing room.

In the Wild Pokémon room from option C you are put in a short maze and the objective is just to walk to the end facing random encounters. It is very important to make sure the first Pokémon in your team can run from these encounters to avoid receiving status or wasting PPs unnecessarily.

Finally, you have the option of challenging the Battle Pike at Level 50 or at “Open Level”, which means the opposing NPC’s Pokémon levels will be the maximum value between 60 and the highest level in your team. If your Pokémon are at level 55, opponents will be at 60, and if your highest level is 81, opponents’ will be 81 as well. This is mostly irrelevant for how hard the challenge is, except that at Level 50 you won’t encounter certain Pokémon that evolve past it (e.g., Dragonite, Tyranitar).

That covers the mechanics. Now the question is how to win consistently.

The Decision Problem

The information you have when you enter a room is:

• The state of your team: are your Pokémon healthy or not? How much PP do you still have on the most important moves? Do you still have your items?
• How many rooms do you still have to go through?
• The quote from the NPC describing what’s behind one particular door.

The other 2 exits are random and equivalent, so you either exit through the room the NPC just described or one of them. Which means you have to weight in what can happen at each room by estimating how much you can afford to lose and still be able to complete the challenge. For example, if you have a single Pokémon left and you get the quote “I seem to have heard something…It may have been whispering”, that exit will lead to No Event necessarily, as previously mentioned.

The decision problem, then, lies in judging the current state of your team and seeing what outcomes are possible based on the quote you get. And choosing the ones which maximize the chance you’ll be able to survive all rounds.

Suppose you start a new challenge. Thus, your team is fully healed. The NPC gives you the following hint: “Is it…A Trainer? I sense the presence of people” about the room in the right. What can be inferred from this situation?

That means this room either has a Single Battle or Full Recovery. However, you can’t get a recovery room if your team is fully healed, so you can conclude there’s going to be a Single Battle behind that door.

The other two rooms represent the 6 alternative paths, corresponding to the outcomes from options A, C, and D, due to option B being the one mentioned in the quote. What can happen if you take them are the following:

• Option A (either Status Condition or One or two recovery): you can’t get recovery, so it’s guaranteed Status Condition. Bad!
• Option C (either Wild Pokémon or Hard Single Battle and Recovery): you can’t get recovery, so it’s guaranteed Wild Pokémon. But you made sure (right?) that your first Pokémon is able to run away from these encounters, so this is a free room. Good!
• Option D (either No Event or Double Battle): both can happen, but Double Battles tend to be relatively simple most of the time, and No Event is obviously great. Good!

That means 2 out of 3 possible scenarios for the rooms not mentioned in the quote are Good and you should take them (which one doesn’t matter). You can still get unlucky and get Status Condition (⅓) or a Double Battle (⅙), but it’s better than a guaranteed Single Battle (which we already defined as generally harder than Double Battles).

Now let’s suppose you are at the last room before the challenge ends and it’s not a battle against Pike Queen Lucy. You can only face Pike Queen Lucky after round 2 (14 rooms cleared) and round 10 (70 rooms cleared). The NPC gives you the quote: “For some odd reason, I felt a wave of nostalgia coming from it” on the central path. In this case, you should always go for that door: you either get recovery or status condition, which is not a problem due to this being the last room.

Here are the heuristics described in the original Reddit post, organized as a Decision Table, with additions by me. “Lightly Damaged” means your party has almost 100% HP or used a few PPs, etc; it’s close to Full Health, but recovery rooms will show up.

Conclusion

What’s charming about the Battle Pike is that it is upfront about luck: “Where the luck of TRAINERS is put to the test…”. And while that is a frustrating aspect of playing Pokémon, it’s also so characteristic of the series that I cannot think of battling without accounting for it. Some amount of luck is required to win, independent of how much preparation you got.

There’s probably more situations in the series where a Decision Table like the one in this post can be used to describe the solution to a particular challenge. Unfortunately, it’s hard to justify the time investment:

• Outside of Battle Facilities, the in-game challenges are fairly simple and writing a Decision Table for most of it would be a waste of time.
• The complexity of competitive battling makes almost any kind of theoretical treatment worthless. There’s just too much to take into consideration. I might reconsider this once I get to study Game Theory more throughly.

Maybe there are other Facilities where this methodology would be useful? I’ll keep my eyes open next time I play.

References

1. This Reddit thread is what inspired me to write this post. ⟶ Advanced Techniques for the Battle Pike (r/PokemonEmerald subreddit).
2. Battle Pike on Bulbapedia.
3. Battle Frontier on Bulbapedia.
4. The generalized term for these minigames is “Battle Facility”:
   • Battle Facility on Bulbapedia
   • Battle Facilities Discord
5. There are many reports from people of the Battle Facilities community listing what teams and strategies they used. It’s likely that this post could be augmented by information posted there. ⟶ Battle Pike Records on Smogon.
6. Pokémon Emerald Post-Game Checklist.
7. Several references on ribbons, marks, and the Ribbon Master Challenge:
   • Pokémon Ribbons subreddit
   • What is the Ribbon Master Challenge?
   • List of Ribbons and Marks by index number in Generation IX
8. Decompilation of Pokémon Emerald.

And here’s the app: dotted paper generator.

Why dotted paper?

I like having scratch paper while I’m at my computer for scribbling, doodling, making quick notes & lists, or just sorting what I want to do in that particular day.

Dotted is superior to regular ruled paper for this kind of usage. It’s mostly out of the way when one is working free form, but flexible enough that you can write as if it was lined, easier to draw with proportions, etc.

I have a large pile of old printed pages (300+) I use as a scratch pad and thought it would be cool to print a dot grid on them instead of just using it as plain paper. So I began searching for a free generator online and found Rob Shearer’s webapp after stumbling upon some of the problems he mentioned in his post, like generators which left annoying watermarks on the created PDF.

I used that app for a few months until I noticed I kept (manually) adding a vertical line splitting the page into more or less 70% / 30% sections. Writing and longer lists on the left side, short reminders and minimal lists on the right one. It’s not perfect, but it works well and is similar to how I’ve organized my study notes for almost a decade now.

Modifications

So I cloned the project and made the following changes to it:

1. I added an option to create a vertical line on top of one of the dotted columns. The input takes a percentage, which is translated to the nearest column. I suspect this might be a problem in tighter grids, but I couldn’t find any problems after a few minutes of superficial manual testing.
2. I like to write page numbers on the top right because I archive these sheets after using them. (I don’t have a strong reason for it.) So I added another option to add a field on the top right for a page number. I didn’t adapt it to mirrored pages, so it does look weird. I might fix this someday.
3. I updated the default values on some of the inputs so it’s closer to what I like to use.
4. I also added a tiny bit of basic CSS and updated the HTML so it uses a form. Given this is a small, single-page app, etc, this is probably unnecessary, but I like how it looks now.

I should prepare a pull request with the HTML and CSS changes I made to thank Rob for his work, too, someday.

I was chatting with some friends on IM when someone posted a link to a Psyduck. The image had the following instructions: “Now open this in Firefox”. And so I did, and it now said “Now open this in IE (or Chrome/Safari)”, presented with a different background color.

What.

Pattern matching against the User-Agent of the HTTP request to send two different files was my first guess. However, the PNGs downloaded through each browser were identical. Worse: the same behavior was present with the file copied locally, so it should be something with the image itself.

Since I never read about image file formats in depth, I had no clue what could be going on. So after finding out about the chunkypng gem, I started poking around the PNG and found out how to look at its chunks.

>> require 'chunky_png'
>> q = ChunkyPNG::Datastream.from_file "psyduck.png"
>> q.each_chunk {|chunk| p chunk.type}
"IHDR"
"acTL"
"fcTL"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"fdAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IDAT"
"IEND"
>> q.each_chunk { |chunk| if chunk.type == "acTL" then p chunk end }
#<ChunkyPNG::Chunk::Generic:0x0000010160f570 @type="acTL",
  @content="\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x01">

Can you see the acTL block? It isn’t in the PNG specification. After a few minutes of Googling, it was clear that this block is only available in a related file format called APNG, an extension to PNG enabling animated images similar to GIF.

The first byte @content of the acTL block is the number of frames (only 1) and the second one is how many times to loop the APNG (source).  From the spec, there’s always a “default image” (described by the IDAT blocks, exactly like a normal PNG file), thus this extra frame should be the second Psyduck image.

To confirm this hypothesis, I installed pngcrush and removed the acTL block:

$ brew install pngcrush

# Remove the `acTL` block from psyduck-original.png.
$ pngcrush -rem acTL psyduck-original.png psyduck-no-animation.png

I ended up with an image that will look the same independent of the host browser:

Searching led me to the cause of the discrepancy: only Firefox and Opera have support for APNG files! From this post in Google’s Products forum and this ticket in Chromium’s issue tracker, WebKit/Chrome doesn’t support the format and probably won’t for some time. Also, from the spec:

APNG is backwards-compatible with PNG; any PNG decoder should be able to ignore the APNG-specific chunks and display a single image.

The mystery is solved: the image is correctly treated as an APNG when opened on Firefox, the animation runs for 1 frame, and you see the second frame. On the other hand, in Chrome/Safari, it is read as a normal PNG, the extra block is ignored, and the default image is shown.

That was fun.

References

1. The PNG specification
2. The APNG specification
3. APNG support across browsers

The Quotes Generator

I use Tumblr to interact with fandoms I’m interested in. One of the kinds of posts I enjoy are quotes from authors, which I use as a signal to find new books to read instead of book reviews. Over time, these posts I reblogged grew into a decent-sized collection of quotes which I enjoy rereading from time to time, sort of like a “quotation book”.

This post shows the construction of a Generator plugin that updates a website with product information from a JSON file. That inspired me to write something similar for myself: the plugin would pull data from Tumblr, save it onto a JSON file, then create a new page showcasing the quotes.

There’s an example of a generator plugin in the GitHub wiki: This example lived in the wiki on the repository before the documentation was moved to the jekyllrb.com website. (2026-03)

module Jekyll
  class CategoryPage < Page
    def initialize(site, base, dir, category)
      @site = site
      @base = base
      @dir = dir
      @name = 'index.html'

      self.process(@name)
      self.read_yaml(File.join(base, '_layouts'), 'category_index.html')
      self.data['category'] = category

      prefix = site.config['category_title_prefix'] || 'Category: '
      self.data['title'] = "#{prefix}#{category}"
    end
  end

  class CategoryPageGenerator < Generator
    safe true

    def generate(site)
      if site.layouts.key? 'category_index'
        dir = site.config['category_dir'] || 'categories'
        site.categories.keys.each do |category|
          site.pages &lt;&lt; CategoryPage.new(site, site.source,
                File.join(dir, category), category)
        end
      end
    end
  end
end

After a bit of tinkering, I wrote a script that saved a JSON file locally with data pulled from Tumblr’s API, which was fed into a Generator plugin (available here) responsible for creating a page to showcase those quotes. This process made me curious about how all those Markdown files are handled internally and I decided to investigate it further. My first mental model involved different data structures holding all the generators, converters, &c, that were invoked during the “compilation” of the site, but I still wanted to know how to generate an output HTML without an existing template, effectively creating it during “compile time”.

Exploration

I started with the Jekyll executable. It’s pretty simple: the command-line parameters, the defaults and the _config.yml (through Jekyll::configuration method) are used to create an options hash and then a new site is instantiated:

# Create the Site
site = Jekyll::Site.new(options)

After that, it starts watching the necessary directories if the --auto option was used:

if options['auto']
  require 'directory_watcher'
  puts "Auto-regenerating enabled: #{source} -> #{destination}"
    # ...
else
  puts "Building site: #{source} -> #{destination}"
    # ...
end

The site is built through a call to #process, the main method in the Jekyll::Site class. Finally, it runs the local server if --server was specified.

Now to check how #process actually creates the website; onto lib/jekyll/site.rb:

def process
  self.reset
  self.read
  self.generate
  self.render
  self.cleanup
  self.write
end

Let’s see what each of these methods do:

• reset: initialize Hashes for the layouts, categories, and tags and Arrays for the posts, pages, and static_files.
• read: get site data from the filesystem and store it in internal data structures (both the ones created in the previous step and in the Jekyll::Site instance).
• generate: call each generators’ #generate method.
• render: call the #render method for each post and page.
• cleanup: All pages, posts, and static_files are stored in a Set and everything else (unused files, empty directories) is deleted.
• write: call the #write method of each post, page, and static_file, copying them to the destination folder (_site by default).

To recap: to create a generator, I need to write a subclass of Jekyll::Generator with a #generate method; that would be called before rendering of the pages and posts. However, I wanted to create the page for the quotes in-memory, which wasn’t playing so well with Jekyll’s rendering. After reviewing how #process works, it is clear that whatever page I create needs to be included as if it was encountered during #read.

Thus, after creating a string representing a page filled with quotes obtained from quotes.json, I had to create a Page object and add it to the internal Jekyll’s data structures. Consequently, #render will take that object and convert it into a complete HTML document that will be written to the filesystem via #write. Here’s (part of) the code from the plugin that implements this sequence:

class QuotesPage < Page
    attr_accessor :content, :data

    def initialize(site, base, dir, name)
      @site = site
      @base = base
      @dir  = dir
      @name = name

      self.process(name)
      self.content = ''
      self.data = {}
    end
  end

# In Site#create_quotes_page
quotes_page = QuotesPage.new(self, self.source, 'quotes_page', 'index.html')

# [...]

# `string` contains HTML generated from the quotes.json file
quotes_page.content = string
quotes_page.data["layout"] = self.config['tumblr_quotes_layout']

# [...]

self.pages << quotes_page

Check the code for the generator at this gist to understand what I’m saying.

I added a page to Jekyll’s repository wiki based on this post.

References

• Jekyll on GitHub
• Generating Jekyll Pages From Data on the Wayback Machine
• The original code for the Quotes Generator lives in this gist, but it’s incomplete.
• Data files in modern Jekyll
• Plugins in modern Jekyll