I mentioned code improvements that make RFC more accessible for modders in my proposal (the essay at the top of this thread). I thought I'd explain in more detail what I had in mind. I apologize if this gets a bit technical.
Without talking down Rhye; the Python code achieving all the magic we know as RFC is all pretty much long chunks of code. As an example, there is a function definition (well, its really a class method, but whatever) called "resurrection". It contains about 200 lines of code, if you don't count commented lines and such. This function is called from one single place in the RiseAndFall.py file and it does everything required for respawning a Civ.
While that is well and in order, it isn't possible to call "resurrection" to make a custom spawn, like in a scenario or a mod-mod. So if you wanna say resurrect the Russian Civ after the Mongol onslaught in a historical scenario, this is no a no go. Because calling this function makes the code first check for Civs eligible for respawn and possibly picking one - and only then doing the actual resurrection stuff. This is of course no good for the scenario we had in mind, right?
So, currently one would basically have to copy-paste all the 200 lines of code, take out the stuff in the beginning about finding and selection a Civ, and then edit the rest of the code so that it does what you want it to. Ok, not so bad then. But what if you wanna do more respawns than just this one? And wouldn't it be useful to be able to do respawns in any scenario/mod-mod without going through all this programming stuff every time?
The solution then, would be to split up all this code into separate functions. So there would be one for initiating a "regular" respawn, then there would be one for selecting a random Civ among all the ones that are dead for the moment, and another one for initiating the actual respawn of a selected Civ, and so on. So you could just intersect the original code where you want and supply all the setting you wanna implement.
Because then it would be as simple as to add something like this to your own code to respawn Russia (as an example):
Code:
initResurrection(iRussia)
It beats having to deal with 200 lines of code, not?
The same thing could be done to other useful portions of RFC Python, like collapses, secessions and so on. You want to be able to initiate your own plague on a historical date, right? Sorry, not possible without doing your own custom Plague.py file, basically. But it could be made as easy as adding one line of code:
...where the first value would be the starting year, while the second and third values are the X and Y coordinates for the breakout. (Additional settings are of course feasible, and don't bother looking up any historical or geographical references - I just made up the example.)
The next step beyond what I described above would be to move all the RFC specific stuff from the SDK into a XML setup. Like add a XML field to all Civs for birth date. No more recompiling the DLL file every single time you need to change a birth date!
In fact, all the setting for RFC could be transferred into an XML interface for easy modding. What about having a Stability.xml file to edit that allows you to access all parameters and rules involved with Stability?
No programming required to achieve just about anything with the current stability system. (Tech and Civic XML entries could also have their own stability fields.)
All these things are possible - its only a question of getting the work done. I intend to rework some of the Python stuff myself, but anything beyond that is currently out of my reach. But there are also real programmers here, somewhere...