This guide is experimental, featuring steps for use only in Story Mode at the moment.
Additionally, subjects covered here are subject to change pending story mode changes or behavior changes of Macrocoding. And for the purposes of this guide, we will have ‘Programming Exceptions’ from the options menu set to on.
¶ Macrocoding - What is it?
In IFSCL, Macrocoding is a programming tool for structuring, creating and finalizing programs.
In this guide, we will be teaching you how to Macrocode programs. In advance we must clarify: Some instances of macrocoding may not be the same in your game as it is ours', as programming elements are randomized per game.
We will be starting this guide towards the end of Chapter 2, after you first “receive” the book ‘Macrocoding Programming' from Herb and have went to Jeremy's dorm room. You will want to go to the drawer to the side of Jeremy's desk here.
Clicking will give you a prompt to take a ‘Floppy Disk - Code Earth’ Floppy Disk. Take that, and head back to the computer to insert it into the box on the left side of the screen.
Next, click the brightened yellow button.
¶ Structuring (Better than log houses)
Look back to the computer.
Two new windows should pop up, one for the Floppy Disk player, and the ‘Code’ window.
When creating a program for the supercomputer, you need to Structure it first. You do this by filling in the blocks here with keywords that will be processed by the supercomputer (or in this case Aelita) to create the base code of the program. In order to do this, we must consult a book related to the program that we studied beforehand.
Prior to this moment, Jeremy would have studied and written notes in the book ‘The Electric Girl’, found in your inventory.
Flip through this book, and you will notice markings like B014.
These markings are generative codes to be used for code structuring, and you can find them in the ‘Macrocoding Programming’ book on the yellow pages.
(Alternatively you can click the yellow sticky note at the top of the page to go directly to the start of the code structure chapter, and flip to the next page from there.)
In the game used for this guide, The Electric Girl book gave us these values:
B004- USER_AFFECTB008- CUSTOM_INPUTB014- TOWER_ANALYSIS
If these same values do not show up in your game, then reference whichever ones do show up.
With these in mind, we will now want to add them to the program structure using fd commands.
You can enter them in any way you like by replacing the number with any of the beginning numbers of the code blocks in the window. For our game, we will do:
fd.0.user_affectfd.1.custom_inputfd.2.tower_analysis
Next, type in fd.sim or fd.simulate to test the program. After it's done testing, if you get a Green (!) window pop-up, it means you have done everything correctly. If you get a Red (!) window pop-up, then it means the code is invalid. Read the error that shows up afterwards to find out what went wrong.
But once it's ready, enter fd.save to save it to the floppy disk.
Lastly, in this part of the story chapter, you will need to upload the program to Aelita. You can do this by opening the lyokoconnect (or just type lyokoc) window, and type in lyokoc.syncfrom.fd or lyokoconnect.syncfrom.fd
That will conclude the segment on Structuring programs.
Next up will cover putting the finishing touches on the Monoscan program in:
¶ Bug Fixing (Hello, IT here, have you tried turning it off and on again?)
This next part of the guide will start after you've begun a coding session in the library, on Chapter 3.
Turn on the laptop by clicking the screen, then take the floppy disk and insert it into the laptop's FD slot.
As with before, press the button or use the fd commands.
The Macrocode window will now show up on the computer screen. Unlike with Structuring, all the code is already there, but it has some errors that need fixing before the program is ready.
It may look different on your game, but the rules of execution will be generally the same. For the sake of this guide, we will be tackling the problems as shown here.
Now to begin with, focus the Macrocode window with either CTRL+TAB, or double-tap it (or else you won't be able to interact with it at all). Then using the arrow keys or the mouse, press enter on your keyboard or click a code block (Marked by highlighted text) to begin debugging. (In our case, we will be clicking BLOCK://INITIALIZATION)
Now you'll be seeing a lot of code, with another or multiple highlighted lines. These are the ‘errors’ in the code, which you can see how many are present in the top right as “Issue(s)”.
Don't worry too much if you can't understand all the ‘programmer jumbo’ here, you won't need to know everything, only the important things. Like for instance; Functions. In Macrocoding here, functions have a ‘start’ and an ‘end’ parameter. In the screenshot above, you can see the function our error is in, where dynamic_reset is the beginning, and -end reset is the ending. These bits and certain context clues of the code of the function, as well as the name of the code block (which was the highlighted text you clicked to get here), are important to keep in mind for programming exceptions. (A situation where a piece of code needs to be altered into a conditional form.)
For now, we need to focus on fixing this error, so, open up your inventory like before and flip through the pages of the ‘Macrocoding Programming’ book. After the yellow pages where you found structure codes, you will come across a chapter titled “Code Editing.” (Like before, you can also click on the green stickynote bookmark to go straight to the chapter beginning.)
What we will be looking for is the reference code that the error is (which may be different depending on the error you're dealing with). In the case of this guide, we want to look at the “sub method” for ‘fragment’.
As you can see from the ‘correction examples’, fragment22 is not correct. To the right, we also see a page for “exceptions to the rule”. Mentioned earlier, these are the conditional forms of the code that you would use if there was something specific about the code's structure. In this case, the exceptions would apply if the “code-block type” had a certain word in it, which as it happens for this problem, it does. The name of the code block we entered to get here; BLOCK://INITIALIZATION
So this means we need to use fragmentstart for this line of the code.
Now with that out of the way, we can work on other errors. For the sake of this guide, we cannot cover every instance of programming sub methods and their exceptions in complete detail, or else it might take a day to finish reading this. However, we will do one last error in this part of the guide as a way to compare coding with exceptions, to coding without exceptions, before finishing this lesson. Additionally, there will be a stub at the bottom that gives the raw details and a brief explanation for subjects not covered in this part of the guide.
The next error on our game involves the sub method ‘matrix'
Like with before, we can see from the correction examples that matrix44 is not correct. It would need to be matrix66 but with one exception to the rule. If the method name (The name of the Function) includes the word “reset.”
The function this error is in is labeled static_spawn, so this means we just need to use matrix66.
Now, once you have fixed all the errors in the code, type in macroc.sim. This command will have macrocode simulate the programming, and will give you a result, telling you what code succeeded, and what code failed. (If any of the code failed, simply go back and fix the errors it talks about. Make sure to read the name of the code block, and bear in mind any rule exceptions as described by the book.)
With that, this concludes the segment on bug fixing. Note you will need to use what you learned here to fix any remaining errors in the code with any of the other code blocks that are error'd. It is important to remember that issues shown here won't be the same in your game, and changes per game-start.
Now, moving on for the last part of this guide, we will begin:
¶ Finalizing the program (A pipedream for programmers everywhere)
When the code is finished, with all errors fixed, the bottom of the macrocode window will gently flash with the words ‘Compilation ready'.
Compile the code with macroc.compile.
The code will start scrolling and a new window will open with a Tower shown. Next, enter macroc.exe.
After a moment of running and a nice graphical show, it will give you a big colored sign showing the status of the program. (In this case, a big green plus.)
This means the program works, and it is now ready to burn to a CD (Note: Do not put CDs into fire.)
Eject / Remove the floppy disk from the laptop, and head to Jeremy's bedroom. From there, grab a CD out of the drawer like you did the floppy disk in Structuring, go to the PC at the desk, and put both the FD and CD in.
Look back to the computer screen and simply type in cd.syncfrom.macro.
It will take only a couple seconds, but after the burning is done, the CD will eject. (If it somehow doesn't, either type in cd.eject or press the green button on the side of the computer.)
¶ Conclusion:
Hot off the press itself, you now are the proud owner of the Monoscan cederom. (CD Disc, if you will.)
Programming here was a bit of a doozy, wasn't it? If you got any game designer/programmer friends, maybe now you should take the time to pat them on the back, give ‘em a cup of coffee, and tell them “Good job.” (Programming isn’t this easy though, so the gesture will surely be extra appreciated)
That will be all for this guide.
Of course, we haven't forgotten either. Below is a list of the sub methods and their rule exceptions, in case you still don't understand how to use them properly at this point. (Don't worry about it, we all have our troubles.)
You can also consider this a more translated ‘cheatsheet’ for the problems you may run into.
¶ Sub-Methods & their exceptions
Change any ‘matrix’ line to matrix66, or:
- If method name (name at the beginning of the function) includes “reset”, then change line to
matrixinfinite
Change any ‘systemic’ line to systemicglobal, or:
- If method type is
_load, then change line tosystemicload. - If method type is
_unload, then change line tosystemicunload.
Change any ‘recomp’ line to recompfloor, or:
- If method type is
static_, then change line torecompceil.
Change any ‘fragment’ line to fragmentdata, or:
- If the name of the code block (what you click to edit in the macrocode editor) is
BLOCK://INITIALIZATION, then change line tofragmentstart. - If the name of the code block is
BLOCK://AUTOMATOR, then change line tofragmentauto. - If the name of the code block is
BLOCK://USER_AFFECT, then change line tofragmentavatar. - if the name of the code block is
BLOCK://TERMINATE, then change line tofragmentends.