Marin's Compiler v1.0

Comma based PBS looks like moves.txt, which works per-line. Each line is a new entry which follows a specific format, like so:

Let's say we put this in a file called new_pbs.txt, and we want to compile it to a data file called new_pbs.dat. The code would look like this:


To break this down, the code that actually formats the text into data is this bit:

"icseei" is the format this PBS file should follow. Each character stands for one field and expects a certain data type (number, string, internal name, etc):

• s : String. This is a raw piece of text. You don't need to surround this with double quotes, UNLESS you want a comma in your string. In that case, you must surround your text with quotes, like so: "Hello, world". Despite this, I suggest to always use quotes around your strings because they make it all the more obvious they're strings. It doesn't make a difference.
• i : Integer. This is a whole number (negative or positive, doesn't matter)
• e : Enumerable. This is a list of values the field can have. If your field has to be a move, for instance, you would use e with PBTypes (you'll see how that works further down). In this PBTypes case, you could use NORMAL, but also 1, because that is the ID of the Normal type.
• b : Boolean. true/false, yes/no, y/n, YES/NO, etc.
• c : Internal name. Cannot contain characters like !@#$%&^*()-= and some more.
• h : Hexadecimal. 0x3E for instance, but just 3E or 03E would also work. (moves.txt's function code is a hexadecimal)
• f : Float. This is any number with decimal places, such as 1.9 or 5.4.
• * : Repeats the last character infinitely many times.

Aside from this format, you can also pass extra options along with that format. This is optional, but for e, you have to give it an option.
This is what nil,nil,nil,PBTypes,["Physical","Special","Status"],nil means that you see there. It applies to the respective characters. So in the example above, it would be like so:

• i = nil
• c = nil
• s = nil
• e = PBTypes (this means it has to be the internal name of a type or its ID)
• e = ["Physical","Special","Status"] (means it has to be one of these three (without the quotes!))
• i = nil

These are referred to the "options" of the format. They always default to nil. This means that our last nil was redundant, because, if we took it out, it would still be nil anyway.

Each format has its own options it can accept:

• s : A number (e.g. 7). This is the maximum length of the string. It can have 7 characters or less, but not MORE than that (e.g. 8).
• i : A Range (e.g. 1..9) : This means it can have any number between 1 and 9, INCLUDING 9.
  1...9, three dots, means it can have any number between 1 and 9 EXCLUDING 9.
  An Array (e.g. [1,3,5,7,9]) means it can have any number inside of that array, and JUST those
• e : A Class/Module (e.g. PBMoves, PBSpecies, PBTypes, PBItems) which will use the constants inside as possible values (e.g. MEGAHORN, BULBASAUR, NORMAL, REPEL, respectively)
  An Array (e.g. ["Physical","Special","Status"]). Here, the value in the PBS can be Physical, Special, or Status.
  A Hash (e.g. {"Physical"=>0,"Special"=>1,"Status"=>2}). Here, the possible values will be the keys (Physical, Special, or Status, just like with arrays), but the formatted data will be the VALUES of those keys (so if you wrote down Special in the PBS file, the formatted data would be 1 rather than "Special")
• b : None.
• c : None.
• h : None.
• f : None.

So now, if we ran our example code, the generated results would be
[1,:MEGAHORN,"Megahorn",6,"Physical",120] and [2,:BUGBUZZ,"Bug Buzz",6,"Special",90] respectively. The line where I do lines[line[0]] = line[1..-1] takes the first element in these arrays (1 and 2) and uses them as array indexes on lines. It then sets the values of those elements to line[1..-1], which is every element EXCEPT for the first one, so that would be [:MEGAHORN,"Megahorn",6,"Physical",120], for instance.
Before you do that, however, you can add extra processing to your line. If there's a field you want be very special and that can't be done using the file format or options for those, you can modify it even more before lines[lines[0] = line[1..-1] to your liking. For example, if we wanted to upcase the "Megahorn", we would write:

After all this processing has been done, lines is [nil,[:MEGAHORN,"MEGAHORN",6,"Physical",120],[:BUGBUZZ,"BUG BUZZ",6,"Special",90]].
We save it to the data file by writing MarinCompiler.save_file(lines). This saves the data to new_pbs.dat, which is what we called our Data file.




In the next proc, the load proc, we load the data file and save the content to a global variable, $NewPBS in this case:

MarinCompiler.load_file loads the data in our specified Data file, new_pbs.dat in this case and sets $NewPBS to that.




If we wanted an OPTIONAL field in our PBS, we would write the character in UPPERCASE. For instance, this below would be possible:
... If our format was icsS. Here, the last S, a string, is OPTIONAL.
If the format was icss, it would say we're missing a field on the first line, because it's not optional.

Before reading this tab, make sure you've read the Comma based tab as well, because it introduces a few terms and explains some parameters that I also use here.

Section based PBS looks like pokemon.txt, which works per header/section. It too follows a certain format, such as this below:
(As you can see, it doesn't matter if you have a space before or after the equal sign.)

InternalName is an internal name, so that would be the c format.
Type1 is a type, so we'd use e with PBTypes.
Type2 is a type, so we'd use e with PBTypes, BUT, because it's optional, we use E rather than e.
Height is a decimal number/float, so we'd use f for Float.

MarinCompiler.register(pbs_file,data_file,compile_proc,load_proc,decompile_proc = nil) stays exactly the same as before.

The full code to compile and load this would be as follows:

This produces a hash that looks like this:
So $NewPBS[1]["InternalName"] would return :BULBASAUR, for example.


You can also use the comma based format INSIDE the section based format. For instance, if you wanted to have something like this:

Here, our code would be

The result would be:

The 1 in [1, 10], is the species Bulbasaur, and the 10 is the integer we gave it.
The 1, 2 and 3 are the IDs of the moves MEGAHORN, ATTACKORDER and BUGBUZZ respectively.
Perhaps this will prove useful at some point.