RPG Maker Forums

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.

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

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

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)

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)

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)

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)

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.

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.

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.

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).

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.

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.

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