My Views On RMVXA Scripting Proficiency Levels

[DoubleX]

I make this general categorization as a mere reference based on my experiences and observations so far:

Level 1 – No Scripting Proficiency

Spoiler

People at this level simply know nothing about scripting and Ruby, and sometimes even programming in general.

Nevertheless, they might still be able to barely read codebases having less than 100 lines on their own, if they’re the most readable ones for them.

Level 2 – Little Scripting Proficiency

Spoiler

People at this level know the Ruby fundamentals, but probably nothing about the exposed parts of the default RMVXA scripts.

Nevertheless, they can still write the most elementary Ruby codes on their own without touching the default RMVXA scripts even though they might not work as intended, and they can likely handle codebases having less than 300 lines on their own without troubles.

Some example scripts:

DoubleX RMVXA rand Edit

Level 3 – Some Scripting Proficiency

Spoiler

People at this level know the basics of the exposed parts of the default RMVXA scripts, but are probably still inexperienced scripters. They’re also the juniors in the RMVXA scripting communities.

Nevertheless, they still have written few simple RMVXA scripts on their own and they all work as intended, and they can likely handle codebases having less than 1000 lines on their own without troubles.

Some example scripts:

AKEA Active Time Battle

Customisable ATB/Stamina Based Battle System

dbchest's ATB

DoubleX RMVXA Basic ATB(without addons)

DoubleX RMVXA Pixel Movement

DoubleX RMVXA State Counters

Yanfly Engine Ace - Buff & State Manager

Yanfly Engine Ace - Command Autobattle

Yanfly Engine Ace - Convert Damage

Yanfly Engine Ace - Gab Window

Yanfly Engine Ace - Instant Cast

Yanfly Engine Ace - State Animations

Yanfly Engine Ace - System Options

Level 4 – Decent Scripting Proficiency

Spoiler

People at this level have a solid understanding of the exposed parts of the default RMVXA scripts and are experienced scripters, and they begin to realize the importance of the code qualities. They’re also the majority in the RMVXA scripting communities.

They’ve written dozens of decent RMVXA scripts on their own and all those scripts have decent code qualities, and they can likely handle codebases having less than 3000 lines on their own without troubles.

Some example scripts:

$D13x - Exp Control

EST - ENEMY / ACTOR POSITION v 3.2 (SCOPE_CONDITION)

VE - Active Time Battle

Yanfly Engine Ace - Class System

Yanfly Engine Ace - Learn Skill Engine

Yanfly Engine Ace - Skill Restrictions

Yanfly Engine Ace - Steal Items

Yanfly Engine Ace - Victory Aftermath

YSA Battle System - Classical ATB(with the original addons but not any DoubleX RMVXA edits)

Level 5 – Advanced Scripting Proficiency

Spoiler

People at this level have a thorough comprehension of the exposed parts of the default RMVXA scripts and are scripting veterans, and they begin to learn how to balance and prioritize the code qualities in every part of all their codes. They are also capable to be excellent scripting teachers, and to specialize in specific scripting domains.

They’ve written at least 1 advanced complex scripts on their own and the code qualities of every part of all their codes are well balanced and prioritized, and they can likely handle codebases having less than 10000 lines on their own without troubles. Their code qualities are exceptional among the amateur programmers.

Some example scripts:

Battle Engine Symphony(whole system)

DoubleX RMVXA Enhanced YSA Battle System: Classical ATB(whole system)

MOG ATB(whole system)

Theolized Sideview Battle System(without addons)

VE - Animated Battle(without addons)

Level 6 – Marvelous Scripting Proficiency

Spoiler

People at this level have a fluent command of the exposed parts of the default RMVXA scripts and external tools that can be used directly by scripts, and are senior scripting experts having years of professional programming backgrounds or equivalent experiences. They’re probably outstanding in some of their specialized scripting domains as well.

They’ve written engines and systems, each consisting of several advanced complex scripts with external tools that work as a whole, on their own, and they can likely handle codebases having less than 30000 lines on their own without troubles. Their codes are highly optimized for their addressed situations, and their code qualities reach the commercial level as well.

Some example engines/systems:

Luna Engine(if it's entirely written by 1 single scripter only)

Level 7 – Sophisticated Scripting Proficiency

Spoiler

People at this level have an incredible mastery of the exposed parts of the default RMVXA scripts and external tools that can be used directly or indirectly by scripts, and their specialized scripting domains. They’re gifted scripting maestros making them the ace scripters and fantastic RMVXA elites, and they can fathom how RMVXA can be written from scratch even without violating the EULA.

They’ve written complete softwares on their own that work ideally with RMVXA, and they can likely handle codebases having less than 100000 lines on their own without troubles. Their codes are maximally optimized for their addressed situations, and they can flawlessly solve the hardest issues in RMVXA that most of the others won’t even stand a remote chance.

Some example complete softwares:

MGC ISO Engine(just my wild guess)

Some of the probably hardest problems that might be still possible to be solved:

2.5D/3D Isometric ABS(with maximally customizable AI)

2.5D/3D Isometric Camera(supporting displacements, rotations and zoomings like H-mode7)

2.5D/3D Isometric Lighting(with 2.5D/3D isometric shadows of course)

2.5D/3D Isometric Mouse(aiming, movement, etc)

3D Audiovisual(3D earphone simulation, 3D line of sight, etc)

3D Destructibles(bigger 3D objects can be decomposed into smaller ones)

3D Mechanics(statics, kinematics, dynamics, etc)

3D Pathfinding(with maximally customizable conditions and constraints)

3D Ragdoll(with 3D Hitboxes of course)

Gems Importer(so scripters can easily import Ruby Gems into RMVXA with simple operations)

Multilayer Parallex Map Editor(which works as if it were built in in the first place)

Multiple Platforms(even though it's built in for RMMV already)

Realtime Connections(even though it'll be much easier to be done in RMMV)

RGSS3 IDE(which works as if it were built in in the first place)

Clients And Servers(based on realtime connections of course)

For those likely being beyond Level 7, game engines being much, much more powerful than RMVXA are probably needed to fully utilize their capabilities.

My views on ways to move up to higher levels

Spoiler

From Level 1 to Level 2

Try to learn the Ruby basics. Resources like these can help:

RGSS3 Scripting Tutorial Videos

RubyMonk(start with Ruby Primer first)

You'll especially want to start with the Hello World examples if you also know nothing about programming in general.

Just makes sure you keep practicing what you've learned during your learning courses, as it generally makes your learning much, much more effective and efficient.

The best way to practice is to write rudimentary scripts that doesn't have to touch the default RMVXA scripts at all and publish them to the RMVXA communities.

From Level 2 to Level 3

Spoiler

Try to learn the RGSS3 basics. Resources like these can help:

RGSS3 Scripting Tutorial Videos

Slip into Ruby: An introductory guide to RGSS for beginners

During this transition, you should focus on grasping basic knowledge of the exposed parts of the default RMVXA scripts, by concentrating on knowing what they do(intents) locally but not how they work(details) locally.

You'll also want to explore more about Ruby. Resources like these can help:

Ruby Doc

RubyMonk(try Ruby Primer Ascent)

Just makes sure you keep practicing what you've learned during your learning courses, as it generally makes your learning much, much more effective and efficient.

The best way to practice is to write few simple scripts that mainly edit and use the default RMVXA scripts and publish them to the RMVXA communities.

Being willing to learn from others' simple scripts(and even edit them) will be a massive bonus too.

From Level 3 to Level 4

Spoiler

During this transition, you should try to:

- Be familiar with dry running methods locally, as you'll have to be able to reason about methods locally in order to understand how they work locally.

- Be willing to delve into technical stuffs. Doing so gives you accesses to more elegant codes that are harder to understand. Sometimes such codes are called for, so you'll want to be able to use them.

- Form a consistent scripting style that at least makes sense to you and your future self, and preferably as many fellows and even users as possible. It doesn't mean you shouldn't change it even when you find another that's even more suitable for you, it just means you shouldn't change your scripting style without solid reasons.
- Focus on forming a solid understanding of the exposed parts of the default RMVXA scripts, by concentrating on understanding how they work(details) locally, as you should already know what they do(intents) locally.

- Gain experience. The only way to be an experienced scripter is to write more scripts. They should address different situations and demands to make your learning progress further more effective and efficient.

- Search for Ruby best practices and anti patterns. Just don't automatically treat them as dogmas without analyzing and thinking about them beforehand.

Also, from Level 4 and onwards, you'll want to:

- Be critical about your own codes. It's ok that your codes have tons of problems and you spotted none, as you'll likely start to spot more and more of them as you improve. Just don't think your codes are even ideal unless you managed to prove it with objective solid evidences and reasons.

- Be sensitive of all the possible edge cases you can think of. While no one can ever spot all the possible edge cases, you'll still want to to try your best to find as many of them as possible before they become too hard to solve.

- Care about the code qualities and technical debts. While scripts that work as intended without nontrivial bugs can usually meet most demands already, you'll want your scripts to work well so yours will be more likely to satisfy more users better.

- Compare your scripts with those written by the others. You should at least compare those being functionally similar to yours, so you can learn from them.

- Join Ruby, RGSS3 and scripting discussions that you can follow. Doing so can further bolster your scripting capabilities. Also, by now you should be able to judge the values of the others' points, so don't be afraid to be "brainwashed" by the others. Bear in mind sometimes you'll have to experiment their points before being able to judge them.

- Know the other scripters and their scripts. Unless you don't care about compatibilities among scripts written by different scripters at all, you'll want to broaden your horizons so you can solve such compatibility issues more easily.

- Plan ahead before actually writing the scripts. While UML or similar stuffs aren't needed in most cases, you should at least briefly think about the user configuration regions before jumping into the implementation parts.

- Put yourselves into all the stakeholders' shoes. Typically, stakeholders here include your future self, fellow scripters, script users and players playing games using your scripts. Even if you're lone wolves, you'll still want to make their lives easier, which should be a major goal for any user-oriented scripter.

- Try to solve users' requests and commissions that you cam solve. This gives you experiences on user support, which is vital for any user-oriented scripter.

From Level 4 to Level 5

Spoiler

During this transition, you should try to:

- Learn how to properly balance and prioritize the code qualities and manage technical debts in every part of all your codes in the contexts of your situations to be addressed. Realize sometimes you'll have to trade some amount of some code qualities for some of the others, and sometimes some technical debts can do more good than harm in short terms. Just make sure all those technical debts are constantly kept in check before they go out of your control.

- Reason about an entire codebase that can be handled by you as a whole by learning how to grasp its full picture.This is vital for global codebase analysis, decomposition and integration, which is useful for reviewing your own codebases globally and dealing with those written by the others.

- Specialize in at least 1 scripting domain. For instance, if you want to write a powerful animated side view battle system(which will almost certainly be an advanced complex script), you'll have to specialize in that scripting domain in order to stand a reasonable chance. While you don't have to be a professional yet, you should at least be a skilled practitioner in the scripting domains you specialized.

- View the entire exposed part of the default RMVXA codebase as a whole and gain a thorough comprehension on its entirety. Otherwise you probably won't stand a reasonable chance to write any advanced complex script.

- Write an advanced complex script(at least comparable to those listing as example scripts in Level 5). Even though it's not the only way, it still almost always guarantees you to be able to finish this transition effectively and efficiently, albeit writing such scripts usually needs months of dedicated efforts during this transition.

Also, from Level 5 and onwards, you'll want to:

- Manage massive projects and solve complicated requests and commissions. You'll be able to face unbelievably insane issues that can teach you a lot, and you'll be able to help those users that many scripters won't be able to help.

- Share your knowledge to the communities. Doing so can further consolidate and enrich your scripting capabilities, and foster your teaching ability, which is vital to keep your advanced complex scripts user-friendly enough for the less able users(although sometimes you'll have to write specific patches designated for their projects). By now you should be capable and knowledgeable enough to be an scripting teacher.

- Think about all the possible design decisions you can come up with early. For instance, if you plan to write a complicated system, you should decide early whether you'll want to integrate all the features into 1 single script, or use the addon approach(the core scripts only implements the core features, the rest are implemented by separate addon scripts) by carefully comparing them in the context of your situations to be addressed.

- Think in the architectural level. For example, you should comprehend how the exposed part of the default RMVXA codebase resembles(if not just implements) MVC, and how this design decision affect the custom RMVXA scripts. You should also be the architect of your own scripts(advanced complex scripts almost always need crystal clear architectures in order to be manageable).

From Level 5 to Level 6

Spoiler

Since I haven't been here yet(although I might reach here one day), I can only imagine what it would be using my observations so far.

During this transition, you should try to:

- Be a professional in your specialized scripting domains. This makes you outstanding in those domains, so you can address situations in those domains that can only be solved by professionals.

- Be prepared to be fully committed and dedicated to professional programming and treat it as one of your professions.

- Have a fluent command on every exposed part of the default RMVXA scripts. You should be able to command it as a whole as if it were completely written by you alone.

- Have a fluent command on some bachelor degree level computer science knowledge that are useful for you. For instance, if you want to write a pathfinding script working with pixel movement in 2D, you'll want to have a fluent command on the A* search algorithm that are implemented in dlls.

- Learn some useful external tools that can be used directly by RMVXA scripts, like using dll via Win32API. Some problems are inherently calculation intensive, and sometimes they can be solved using dll to make your codes run much, much faster, espeically when they're frequently called.

Also, from Level 6 and onwards, you'll want to:

- Manage professional codebases reaching the commercial level quality. This gives you access to highly optimized codes that you can learn from. Although such codebases are generally hard to find and not many of them are open source, you might still be just that lucky if you tried.

From Level 6 to Level 7

Spoiler

Since I haven't been even reached Level 6 yet, I can only imagine what it would be using my observations so far.

You probably need some talents in order to reach Level 7, even though it's just my wild guess.

During this transition, you should try to:

- Fathom how game engines like RMVXA can be written from scratch. For example, if you want to write a RGSS3 IDE and/or Gems Importer that works as if they were built in in the first place, you'll have to fathom how the default RMVXA editor can be written from scratch and how it can fit into RMVXA as a whole.

- Master every last bit of every exposed part of the default RMVXA scripts. Be an encyclopedia of the entire codebase. Maximally optimizing it is even better.

- Master some master degree level computer science knowledge that are useful for you. For instance, if you're ever insane enough to try to make RMVXA portable to other platforms, you'll definitely have to at least master all the involved operating systems and assemblers in order to make RMVXA games to be able to function like native apps, and mastering all those definitely needs related master degree level computer science knowledge.

- Research on your specialized scripting domains. You'll likely be elites in those scripting domains and might even make groundbreaking and pioneering matserpieces that are invaluable to the communities.

- Solve the hardest issues in RMVXA. You can learn a lot during the attempts, even if you failed to solve them or prove that they can't be solved. If you can solve some of them and/or prove that some of them can't be solved, it'll give tremendous values to the communities.

- Write some complete softwares. Some issues are just so hard that external complete softwares working ideally with RMVXA will be needed, and being able to solve such issues is a major value of Level 7 scripters gives to the communities.

Going beyond Level 7

Spoiler

Simply use a game engine being much, much more powerful than RMVXA

I won’t shoehorn the RMVXA scripting communities into the above categorizations, as I’ll constantly check if the latter still makes sense for the former instead.

On a side note: You probably noticed that I haven't even touched teamwork at all, even though it's integral to scripting proficiencies. That's because uptil now I'm still just a lone wolf so I can't talk much about that

Although not many lone wolves are great programmers and not many great programmers are lone wolves, I won't rule out the possibilities that even lone wolves can still reach Level 7 on their own

You don't have to shoehorn yourselves into this categorization if you think it doesn't apply to you. You don't even have to take it seriously if you think it doesn't make sense at all. You can instead just treat it as an utter joke made by a ridiculously nub scripter

 

[??????]

Nice article; however, I do have a few issues/concerns..

There is a huge difference between your views on stage 5 -> 6, additionally, you only feature battle systems in stage 5, when there are many extremely advanced scripts that are not battle systems - for example, the ISPDS script I wrote, that has around 13-ish accompanying scripts to allow an insane amount of control over all aspects of all stats, including fixed && percentage value element distribution via in game distribution system / script calls..

I mean, things like that are still extremely complex, much more than one would expect from a 'stage 4 system'.

Also, luna engine does not meet the requirements you set out for step 6, nor was it written by only one person. Yes, the majority was one person, but there are many MANY accompanying scripts, such as MGC?? bitmap script && dll..

other than that, this was a good read and I agree with most other views

Edit:

Now I'm wondering what 'stage' I am at...

 

[DoubleX]

Nice article; however, I do have a few issues/concerns..

There is a huge difference between your views on stage 5 -> 6, additionally, you only feature battle systems in stage 5, when there are many extremely advanced scripts that are not battle systems - for example, the ISPDS script I wrote, that has around 13-ish accompanying scripts to allow an insane amount of control over all aspects of all stats, including fixed && percentage value element distribution via in game distribution system / script calls..

I mean, things like that are still extremely complex, much more than one would expect from a 'stage 4 system'.

Also, luna engine does not meet the requirements you set out for step 6, nor was it written by only one person. Yes, the majority was one person, but there are many MANY accompanying scripts, such as MGC?? bitmap script && dll..

other than that, this was a good read and I agree with most other views

Edit:

Now I'm wondering what 'stage' I am at...

About the stage 5 -> 6 thing, if you mean the transition, then that's probably because I haven't experienced it yet. I can only imagine using my observations so far.

If you mean the difference between the description of Level 5 and that of Level 6, then that's because I think that's the separating line between amateur RMVXA scripting proficiency and professional RMVXA scripting proficiency. While Level 5 scripters can already write incredible scripts, when I, currently as a Level 5 scripter, look at what Level 6 scripters works can do(I suspect EffectUs and Invenio belongs to this level but I didn't buy them so I can't judge), I just think I'm still incredibly nub

The reason I only included battle systems in stage 5 is because I'm currently at just Level 5 and I only specialized in Scene_Battle based battle systems(especially atb). I've checked yours, some advanced hud scripts, some insane text editors and script encryptors, but as I don't know much about those domains, I don't think I'll be able to judge which levels those scripts belong to.

About Luna Engine, yes, it's a teamwork lasting for at least 1.5 years. But as it's the only engine/system I'm familiar with that is close to Level 6, if we pretend(although we shouldn't) that it's completely individual work, it could be barely "coerced to" Level 6

In short, unfortunately, I can only judge scripts that I'm familiar with...

Edit:

You're definitely at least Level 5. If you're wondering if you actually reach Level 6, a simple test is to check if you've reached professional level in any of your specialized scripting domains.

While it's rather obvious in some really technical domains like 2D hitbox(or even 2D ragdoll), 2D pathfinding, 2D mechanics, 2D destructibles, 2D Audiovisual(2D directional sound simulation and 2D line of sight), 2D light(with 2D shadows), 2D ABS(with insanely powerful and customizable AI), 2D high-resolution, internet connection(without realtime), in some other domains it can be quite blurred.

In some scripting domains, like atb system, it's even completely pointless to reach Level 6, as even Level 5 atb system scripts are already considered to be generally overkill.

So to make the test produce crystal clear results, just try to challenge some of those technical domains and see if you can write such scripts reaching commercial level qualities

 

[NPC]

The stage transistion section gives a lot of helpful tips and points of focus! It's a helpful device to the perpetual student. 

 

[DoubleX]

The stage transistion section gives a lot of helpful tips and points of focus! It's a helpful device to the perpetual student. 

If you're currently Level 5 or above, you'll want to take extreme cautions when reading Level 5 to Level 6, and/or Level 6 to Level 7, as I haven't experienced any of them, so they're just my imaginations based on my observations.

If you're currently Level 4 or below, those tips are mainly based on my own experiences, enhanced with my observations.

To me, being better in scripting isn't simply a linear practice. There are different stages having different major issues to be overcome.

Going from Level 1 to Level 2 means you'll have to change from knowing nothing about Ruby(or even programming in general) to be able to write rudimentary Ruby codes.

Going from Level 2 to Level 3 means you'll have to change from knowing nothing about the default RMVXA scripts to have a basic knowledge and little experience on them.

Going from Level 3 to Level 4 means you'll have to care about your overall qualities as scripters as well instead of making scripts that just work and downplaying the other aspects.

Going from Level 4 to Level 5 means you'll have to be a scripting architect and skilled practitioner in some specific scripting domains to solve complicated requests and commissions.

Going from Level 5 to Level 6 means you'll have to change from an amateur scripter to a professional one in order to solve exceptionally hard issues needing professionals to solve.

Going from Level 6 to Level 7 means you'll have to change from average professionals to true maestros in order to solve the hardest issues that most of the others won't stand a chance.

Going beyond Level 7 means you'll want to use game engines being much, much more powerful than RMVXA instead in order to further improve your programming capabilities XD

P.S: How can I forgot Theolized Sideview Battle System? It definitely belongs to Level 5. Just added it now lol

 

[??????]

Yea, I meant the transition - it just seems to me that there is an in between, when your not stage 5, or stage 6 yet

like, lets take two examples:

level 4 - Yanfly Engine Ace - Victory Aftermath

level 5 - Battle Engine Symphony(whole system)

Now, the skill level required for a victory aftermath is significantly less than the skill required to write a full battle engine as 'powerful' as symphony.

imo, a fair middle ground (for those two scripts) would be a system that applys somewhat simple mechanics to the actual battle scene - perhaps something akin to jets sideview battle system.


I am quite pleased that you think I am at stage/level 5 of your ranking system, and I dont exactly disagree with you, but I also think that the stages above 5 could use a little more definition..

My (basic) view on how a script level / ranking system (for the likes of RM) would work is as follows;

0 - No Knowledge of scripts at all (whats a script?)

1 - Understands how to use scripts within their own projects - cant write code at all, hesitant about editing script code/customization.

2 - Able to understand && write basic scripts, such as adding a menu command or a new status screen.

3 - Able to understand and write intermediate scripts, but lack the ability to optimize (both in terms of efficiency and amount of code required)

4 - Able to understand, write, and optimize intermediate scripts.. Also has reasonable understanding of the default methods given by ruby - this kind of person should be able to tell you exactly what version of ruby rm ace (or their preferred maker) uses.

5 - Able to undertake extremely complex tasks, and also willing to spend insane amounts of time to bring their systems to life - optimizations of everything is standard. They would have a good knowledge of all classes/modules that their version of rm is exposed to.

6 - Very similar to step 5, except this person would be able to use multiple languages in union with rm && the ruby inside it. This includes interacting with dll's to bring additional functionality not usually seen within ruby/rm - they are also likely to have written the aforementioned dll's from scratch.

7 - This kind of person would be able to replicate RM outwith RM (if that makes sense). They are able to understand how the RM engine was created, they are able to replicate that in some form. For example, creating a new database editor, a new rgss script editor, a new mapping editor (like the MGC one you linked, which the editor was actually made within rm, but still).

Its quite likely that they are employed professionally in some programming role, if not, they likely will be in the future and are using their creations as portfolio objects.

8 - This kind of person would have very little use or want for RM. It is likely that if they were to use it, it would be for educational purposes - such as a high school teacher using it to teach young students basic programming. They would likely have a long lasting professional background in low level programming.

Anyway, kinda ranted on a bit there

Edit:

So to make the test produce crystal clear results, just try to challenge some of those technical domains and see if you can write such scripts reaching commercial level qualities

(imo, of course) My RM Asynchronous HTTP system is second to none! Which I plan on releasing uhh, later this week?

Dunno, my mother is in hospital atm, so I will see how it goes with free time and such

 

[Seriel]

By this leveling system (The OP one and Dekita's one)

I would class myself as level 3.

 

[DoubleX]

First, let me state that yours makes a lot of sense to me

In reality, scripting proficiency's a continuous spectrum. Any leveling categorization's splitting that spectrum by placing separating zones at intervals that makes sense. Those separating zones are the level transitions and what's left are the levels themselves.

As those separating zones are themselves spectrums, one won't suddenly jump from Level X to Level X + 1; As those levels are themselves spectrums as well, one can't assume the code qualities of 2 scripters will almost always be extremely close just because they're at the same level, although any level categorization that makes sense should make them comparable in most cases.

The rationale behind mine is that, as a scripter improves, the major issues he/she will have to overcome will change significantly, so I place those separating zones at intervals where a scripter should change his/her priorities among all the aspects he/she'll have to learn in order to learn effectively and efficiently. The difference between Level X and Level X + 1 in mine are indeed significant though.

Using Level 4 vs Level 5 as an example:

Yes, the difference between Yanfly Engine Ace - Victory Aftermath and Battle Engine Symphony(whole system) are huge in terms of scripting proficiencies needed to write them, and if you compare that between Yanfly Engine Ace - Victory Aftermath and Theolized Sideview Battle System(without addons) or VE - Animated Battle(without addons), the difference's just outright insane.

But if you compare that between VE - Active Time Battle and DoubleX RMVXA Enhanced YSA Battle System: Classical ATB(whole system), you'll probably think that it's much less massive, albeit still significant.

That's because VE - Active Time Battle is likely placed at nearly the top in Level 4 while DoubleX RMVXA Enhanced YSA Battle System: Classical ATB(whole system) is likely placed at nearly the bottom in Level 5.

Even if you compare that between Yanfly Engine Ace - Victory Aftermath and VE - Active Time Battle, you'll still think the difference are very, very crystal clear and obvious.

That's because Yanfly Engine Ace - Victory Aftermath is likely placed at nearly the bottom in Level 4 while VE - Active Time Battle is likely placed at nearly the top in Level 4.

When you compare a script placing at nearly the bottom in Level X and another one placing at nearly the top in Level X + 1 in terms of scripting proficiencies, the difference can be so incredible that you won't believe that's just 1 level difference; When you compare that between a script placing at nearly the top in Level X and another one placing at nearly the bottom in Level X + 1, the difference becomes making much more sense although it's still significant.

About why I think going from Level 5 to Level 6 means such a seeming great leap, that's because from my experiences and observations, Level 5 scripters can already solve the majority of issues in RMVXA and requests in the communities. Most of those that they can't solve likely needs external tools and professional level specializations in the involved scripting domains in order to have a reasonable chance to offer commercial level quality solutions in order to solve them; When external tools are called for, the situations to be addressed are probably exceptionally tough ones needing truly outstanding senior scripters to solve.

 

[DoubleX]

Let's share how I go through from Level 1 to Level 5.

Level 1 to Level 2

Spoiler

Back when I know nothing about Ruby, I've tried to play with some scripts. One particularly caught my interest is Yami's CATB. It's simple yet powerful enough for me at that time, but it has a lot of bugs. I tried to search for workarounds but I found nothing. It also seemed to me that Yami won't support CATB anymore at that time as he/she said he/she'll recode his/her atb.

I wished all those bugs were gone or even didn't exist in the 1st place, but I couldn't do anything. I was so utterly frustrated that I decided to learn Ruby and RGSS3 scripting so I can fix those bugs myself. After all, it doesn't violate the terms of use, and I already have 2 year experience in Pascal and 1 year experience in C++ at that time, so I think I can at least learn the basics.

I searched for tutorials and found DP3's videos so I watched them and practiced what I've learned using the RMVXA script editor during my learning course. I spent 1 week and watched from the 1st tutorial to the 27th. Then I think I became prepared to deal with real scripts so I tried to learn how Yami's CATB works instead.

Unfortunately, things weren't that simple. I realized that even if I know how to write rudimentary Ruby codes, I still have to have at least a basic knowledge to the exposed parts of the default RMVXA scripts in order to deal with real custom RMVXA scripts. The exposed parts of the default RMVXA codebase's too large and complicated for me to even find a place to start at that time, so instead I tried to write some primitive RGSS3 snippets.

My attempt ended up simple snippets like these, even though I called them scripts:

DoubleX RMVXA Action Times+ Edit

DoubleX RMVXA Constants Edit

DoubleX RMVXA Confusion Edit

DoubleX RMVXA Substitute Edit

DoubleX RMVXA CounterAttack Edit

Note that some of them have become much, much more polished now

Level 2 to Level 3

Spoiler

I became able to write primitive RGSS3 snippets, so I tried to deal with Yami's CATB again. After 1 full week of intensive commitment and dedication, I finally managed to learn how it works. I then used another week to finish its bug fix and compatibility fix. I learned how to find bugs and compatibility issues by reasoning about their apparent and root causes, which is an indispensable skill to ensure compatible, correct and robust codes.

On the other hand, I started to receive replies from other users in some of my script topics. As I want to be an user-oriented scripter, I tried to value their inputs and solve their demands. I ended up gaining experiences in end user supports, which is vital for any user-oriented scripter.

So far, I've only written primitive RGSS3 snippets and fixed bugs and compatibility issues of some others' scripts, but I haven't written any real custom RGSS3 script on my own. Coincidentally, an user requested me to write an unison skill/item script which works like Victor Sant's Cooperation Skills, but works with Yami's Battle Engine Symphony instead. That was quite a tough challenge for me but I still tried by writing a standalone script first before writing a compatibility fix addressing Yami's Battle Engine Symphony. I used 1 day to draft the prototype but it failed to work at all, so I wondered why. Fortunately, after a whole 24 hours of in depth abstract thinking with the aid of the basic understanding of the default battle system on the user level, I managed to come up with a standalone unison skill/item script that works.

I expected that that script will solve that user's requests and he/she'll be satisfied, but I haven't thought at all that it'll become even remotely popular. This gives me many diverse user inputs that are valuable to me, and many diverse experiences in end user supports, so I ended up learned a lot just by maintaining that script.

But perhaps more importantly, I realized I finally have a basic understanding on the exposed battle parts of the default RMVXA scripts, so I can write more standalone battle scripts on my own. As I'm mainly interested in battles, that's just a happy match. I decided to march in 3 directions : Expand Yami's CATB's feature sets by writing its addons on my own, writing standalone battle scripts on my own, and challenge some other user requests in which I'm interested and I have a reasonable chance. I ended up writing more and more Yam's CATB's addons and standalone battle scripts, and solving more and more other user requests.

Level 3 to Level 4

Spoiler

I was satisfied. I can finally write scripts that works as intended without nontrivial bugs, and write compatibility patches for them when they're called for. I have a basic understanding of the exposed battle parts of the default RMVXA scripts. I can fix other scripts' bugs and compatibility issues. I can solve some other users' requests. So my focus at that time was to write scripts to turn ideas that interest me into reality, instead of continuing to improve my scripting proficiencies.

However, when I started to write the random cast script, I started to value more on user-friendliness as well. I reflected on how the notetags can be placed, and I begin to disagree with how Yanfly did it, and restrict eval in particular. I wondered if the code string becomes long, the notebox will be cluttered with that script's notetags, which can be a problem if there are many other notetags that are to be placed there. Also, if many noteboxes shares the same code string and that string needs to change, the users will have to change every noteboxes having that string as well.

I've delved deep into that problem for 1 day and I come up with a new design: Instead of asking users to write the code strings into the noteboxes directly, those code strings can be referenced by constants written in the script's user editable regions, so the notetags just have to reference those constants in the noteboxes. Now those notetags become more user-friendly by taking less space from the noteboxes and letting users to reuse the code strings. Advanced users can even set some constants as building blocks so they can build complex code strings from the simple ones, hence further boosting reusability.

I felt even better as I became to value user-friendliness as well, but I only realized I missed many other important code qualities when I decided to rewrite Yami's CATB. At that time, I've already written 15 addons to it. While they all work as intended without any nontrivial bugs found, the entire Yami's CATB codebase(with my bug and compatibility fixes and all addons of course) become(it still is) such an utter mess that I almost want to outright announce technical bankruptcy already as its technical debt become too massive to be even managed, let alone completely paid, on my own. I knew I screwed up Yami's CATB but I still don't want to give up. I analyzed why that's the case and I realized that's because I actually didn't know how to write compatible, maintainable, modular and reusable codes. I thought I knew how to write compatible codes by writing compatibility fixes but that's just an appealing illusion. The sole fact that I had to frequently write compatibility fixes means my original codes' compatibility wasn't as good as I've thought. That's why I decided to rewrite Yami's CATB: Ease my future self when I continue to enhance that script, and improve all the important code qualities that I lacked.

I first tried to "integrate" the entire codebase into 1 single script by literal copy and paste and refactor the whole mess altogether, but after that single script exceeded 3000 lines, I realized that approach wouldn't work for me at that time. I began to understand the meaning and power of scale, so instead I started to rewrite the core feature set first before adding any addon into the mix.

At the same time, I started to learn all the important code qualities that I can find on the internet and I can figure out myself. As I was dealing with an atb system script, time performance undoubtedly stands out so I focused on that in particular.

That also taught me that having a basic knowledge of the exposed parts of the default RMVXA scripts isn't enough for me to write high quality codes, as I need is a solid understanding on them, so I started to learn their details by countless dry runs and code reasonings as well.

After roughly 1 month of rewrite and refactoring, I managed to come up with the ECATB prototype which uses nearly 3000 lines to replicate the Yami's CATB's core feature set.

Before rewriting Yami's CATB, I partially followed his/her coding style as that script is the main reason I entered the scripting realm, but after finishing the ECATB prototype, I found that I disagreed more and more on his/her coding style so I reflected on what my new coding style should be. After another month of thinking and testing when continuing to polish the ECATB core, I managed to form my new coding style that's still used uptil now.

I thought I was ready to add my CATB addons into the ECATB prototype, but shortly after I realized the 3000+ lines barrier was still there: I still became uncomfortable with such scales so I backed down and continue to polish the ECATB prototype instead. I thought time is the only solution for me to be able to deal with codebases with larger and larger scales, so I also started to to join some RGSS3 scripting discussions and open some such topics to hope that I can write even better quality codes.

Level 4 to Level 5

Spoiler

After some time, I finally knew why I couldn't pass the 3000+ lines barrier: The ECATB prototype lacked crystal clear architectures. The only apparent architecture is the MVC used by the exposed parts of the default RMVXA scripts, and it became obvious that it alone isn't enough for the task. So I started to practice to think as an architect by thinking on the architectural level. After all, it's architectures that make codebases easy and simple to scale.

I also immediately understood that architectures that make sense seldom come out of a blue, as they've to properly model the addressed problem domains. So I first thought of the architectures of the entire atb system concept by thinking about it basic functionalities, core structures and fundamental mechanics. Then I tried to expand its feature sets and experimented how those features interact with each other.

To ensure I know how to think in the architectural level, I've thought about how the battle related classes and modules are designed and how they interact with each other as a whole as well. I began to to able to view the big picture of the default battle system implementations too.

Accidentally, I also learned that sometimes the code qualities themselves will be conflicting with each other, so I realized I'll have to balance and prioritize them in these cases. Upon expanding the ECATB prototype by adding my CATB addons, I also understood that such balancing and prioritizations have to be done in every part of the codebases. For example, in almost all hot spots(run x times per frame), time performance can be rarely sacrificed at all, while in some other areas time performance almost means nothing.

Fortunately, I finally managed to finish ECATB, which is an advanced complex script, even though I've spent 7 months on it and it still sucks like hell even after so many updates. The entire process was really painful for me but I still think it's worth going through as I've improved a lot during that 7 months.

That's how I went from Level 1 to Level 5. Of course right now I'm still incredibly nub and I still have a whole lot to learn, so I start to prepare for Level 6 by begin to manage larger scale codebases like Luna Engine and learn how to use external tools like dll.