Lemma Soft Forums

Hi,

This is mainly a brainstorming-type post.

There's an idea I've been toying with for a while, and that is making some type of add-on module that allows you to make RPGs closer in style to RPG Maker VX.

The rational being, that while RPG Maker VX is very nice, it is a commercial windows-only program. And, while you do get several open source RPG creation systems (some of them even with Python scripting support), they're generally require a lot of programming and implementing from scratch. So I was thinking, since Ren'Py is such a nice system to use (in terms of syntax, defining events, multimedia, etc), that it would be awesome if there was more comprehensive RPG support, in the form of a recipe or add-on module.

Most likely, such a module would build on top of the Tile and Unit engine, and also the RPG Frame.

The main difference being, that it would add several more RPG features, in a style somewhat similar to RPGVX. eg, predefined combat, inventory, stats systems and so on, that could be modified if needed. More or less, a (probably simplified) Python/Ren'Py translation of the RGSS2 code found in a default RPGVX project, but using Ren'Py idioms.

Some of the main differences would be:
- Be coded in Python rather than Ruby
- Use Ren'Py's support for animations, for events, special effects, etc.
- Events would be coded in regular Ren'Py scripting (ie, probably very close to the Tile Engine tutorial, over here).

It would be quite a major undertaking though, to code all that, but it might be possible to add just small parts first, to get closer to a RPGVX-like system, by adding parts on top of the Tile Engine over time.

One thing which I think would be a good start (and hopefully not too complicated), is to create a tool which lets you use basic Tiled maps with the Tile Ren'Py engine. Later, it might be possible to support loading maps, or other game data that was originally edited in the RPG VX game editor.

Well, I'd probably never actually get around to implementing all the above (since I'm lazy, and busy with many other things).

But, how feasible would it be, to build a system like that on top of Ren'Py? And, I wonder if anyone would want to use a system like that, if I (or most likely someone else) did some work in this direction?

It's possible to do that, I managed to have some tilemap working with the old versions of Renpy, so with the latest features should be even easier. However there's such a tool being made right now in flash (http://www.koonsolo.com/rpgeditor/) by a very good programmer friend of mine, and I'm not going to make the work twice, so I gave up coding my own
Still for sure there are people that would still like to use such a tool even only made with renpy.

But, how feasible would it be, to build a system like that on top of Ren'Py?

Have you played Science Girls?

Jake is making a very flexible Battle Engine covering a variety of common RPG battle styles -- check his sig.

I support using Ren'Py to make more RPGs. The sequential scene system is just perfect for meta-structure planning. It's hard to do a linear or branching sequence using a 3D engine or any engine that's geared towards collision events.

There is a framework you can use to get started here but other than that you are on your own BUT there are a lot of posts and threads here on how to create an RPG using Ren'Py so if you do a search, particularly in the Ren'py Support section, I'm sure you can find some helpful topics.

jack_norton wrote:It's possible to do that, I managed to have some tilemap working with the old versions of Renpy, so with the latest features should be even easier. However there's such a tool being made right now in flash (http://www.koonsolo.com/rpgeditor/) by a very good programmer friend of mine, and I'm not going to make the work twice, so I gave up coding my own
Still for sure there are people that would still like to use such a tool even only made with renpy.

Thanks for that link, it looks like a pretty interesting idea

Though, not quite what I have in mind. Specifically, I'm interested in RPGs on the Ren'Py platform, which has a number of it's own advantages over other systems

papillon wrote:Have you played Science Girls?

Nope, but I found it over here, and those screen caps look very interesting, thanks for mentioning it. I'll definitely be taking a closer look at it, and see what I can learn from it.

That hybrid style reminds me of some GUST games (eg: Ar tonelico), which also combine VN and JRPG elements.

DaFool wrote:Jake is making a very flexible Battle Engine covering a variety of common RPG battle styles -- check his sig.

Thanks, I found the link over here. And that also looks very interesting

Btw, I think it might be helpful to update the Ren'Py wiki (especially FAQ about RPG support), to point to these examples, to encourage more people to make RPGs using Ren'Py.

DaFool wrote: I support using Ren'Py to make more RPGs. The sequential scene system is just perfect for meta-structure planning. It's hard to do a linear or branching sequence using a 3D engine or any engine that's geared towards collision events.

Yes, I really like it myself.

In regular programming languages, you usually need to deal with complex state or conversation graph management in your game events (like this, see the "Designing natural dialogues made easy" screenshot, heh), or introduce a constrained mini scripting language, just for the event scripting (eg: RPG Maker event code).

Ren'Py scripting is an elegant mix of high-level declarative and imperative programming styles, which also lets you use regular Python anywhere you need to.

It seems very well suited for RPG event coding too, one of the main reasons I'd like to use Ren'Py for RPGs, rather than using Pygame directly, or most other open source RPG maker systems.

rioka wrote:There is a framework you can use to get started here but other than that you are on your own BUT there are a lot of posts and threads here on how to create an RPG using Ren'Py so if you do a search, particularly in the Ren'py Support section, I'm sure you can find some helpful topics.

Thanks, I saw the RPG frame on the wiki, but have spent next to no time on the forum (I'm a very casual Ren'Py user). I think it might help if more of the games and engines (RPG-related) were linked from the wiki . I see I'll need to spend some time in the Support section

Also, speaking of being a Ren'Py user, I have done some work on a kinetic VN in Ren'Py, but it uses a lot of ripped JRPG game resources, so it might be problematic if I posted it here.

Here is a list of free RPG games: http://renai.us/category/rpg
Five of the seven were made with Ren'Py.

As for ripped stuff: there shouldn't be a problem. We have folks here who have done fan games based on popular anime's, games, etc and not all use their own art assets made from scratch. It's like the pot calling the kettle black.

rioka wrote:Here is a list of free RPG games: http://renai.us/category/rpg
Five of the seven were made with Ren'Py.

Thanks for that link . I'll definitely need to take a closer look at those.

Seems like there are quite a few RPGs using Ren'Py out there, already.

Though, I think there might also be some room to add more recipes, so that less needs to be re-invented if people want to make some quick RPGs in Ren'Py, without coding most of their game (stats, inventory, levels, status screens, battle, etc) from scratch.

So I am kind of interested in seeing if I can re-implement parts of the RPG Maker VX system in Ren'Py, in a way that's not too complicated to use (and then people can customize the engine as they see fit, similar to customizing a RPG Maker game by patching the Ruby code). Though, knowing me, I probably won't ever get very far with it (just exploring the idea a bit).

rioka wrote: As for ripped stuff: there shouldn't be a problem. We have folks here who have done fan games based on popular anime's, games, etc and not all use their own art assets made from scratch. It's like the pot calling the kettle black.

Hmm, thanks for that reassurance . I've posted it over here:
http://lemmasoft.renai.us/forums/viewto ... =16&t=8049

wizzardx wrote:

rioka wrote:So I am kind of interested in seeing if I can re-implement parts of the RPG Maker VX system in Ren'Py, in a way that's not too complicated to use (and then people can customize the engine as they see fit, similar to customizing a RPG Maker game by patching the Ruby code). Though, knowing me, I probably won't ever get very far with it (just exploring the idea a bit).

I would very much be interested in it, I know I have a couple RPG games that I'd like to use in conjunction with visual novel gameplay but simply don't have the means to do so. I'm sure many other would be interested as well. Good luck though, that'll be one huge project.

LinWest wrote:I would very much be interested in it, I know I have a couple RPG games that I'd like to use in conjunction with visual novel gameplay but simply don't have the means to do so. I'm sure many other would be interested as well. Good luck though, that'll be one huge project.

Cool

Well for the moment I've started a very minimal (just barely enough to get a couple of basic screens working) conversion of RPG Maker VX's RGSS2 Ruby to Python, which will use Pygame for drawing. Just as a proof of concept, because I've been interested in it a while, but haven't had a good excuse to spend time on it.

After I have a screen or two working, I'll make it Ren'Py compatible.

Though, it will probably be fixed to the RPG Maker VX screen resolution for now, because the RGSS code hardcodes the coordinates. Though maybe I can work around that later, by scaling all the hardcoded coordinates to match the Ren'Py window size.

It will also probably require that you have a Ruby interpreter installed on your PC, if you want to load rvdata data files saved from RPG Maker VX (where you can edit the classes, items, party members, etc, like in a regular RPGVX game). Or alternately, you'd need to run a tool to convert the rvdata files to yaml, or edit the yaml files by hand if you don't have a copy of RPG Maker VX.

It should also be possible to construct all the objects in the Ren'Py code directly (without loading yaml/rvdata), though that would be fairly time-consuming (considering how much detail goes into the rvdata files saved by the rpg maker vx editor).

And of course, you'd also need to convert any custom RGSS scripts (that you normally use for your RPGVX games) to Python, though that should be a fairly straightforward process that any Python coder can do, with a bit of patience to change from Ruby syntax to Python. (There are some auto conversion tools, but I haven't tried them yet).

vincy wrote:Thanks for sharing..............

I assume you're talking about the VN I posted? I hope you enjoy it

rioka wrote:Here is a list of free RPG games: http://renai.us/category/rpg
Five of the seven were made with Ren'Py.

While there are some games written in RPG with RPG elements, generally it means "there are RPG-style battles" rather than giving you (for example) the roaming world-map, and also several of those games don't have any RPG-like elements at all, at least for the purposes of that discussion. For example, Painted Walls is a very standard VN in terms of mechanics; one could argue that it's an RPG in that pretty much all VNs require that you play a particular role (generally that of the protagonist), but there's no elements which JRPG fans would recognise as RPG-like.

(For the purposes of example, Heart of Fire is probably the best one in that list.)

wizzardx wrote: It will also probably require that you have a Ruby interpreter installed on your PC, if you want to load rvdata data files saved from RPG Maker VX (where you can edit the classes, items, party members, etc, like in a regular RPGVX game). Or alternately, you'd need to run a tool to convert the rvdata files to yaml, or edit the yaml files by hand if you don't have a copy of RPG Maker VX.

It should also be possible to construct all the objects in the Ren'Py code directly (without loading yaml/rvdata), though that would be fairly time-consuming (considering how much detail goes into the rvdata files saved by the rpg maker vx editor).

It sounds like rather than writing an RPG framework for Ren'Py, you're porting RPGMaker to Python to be Ren'Py compatible?

I guess you get to re-use the toolset, but it makes me much less interested in the idea if you're also going to be inheriting RPGMaker's limitations... and if you're going to require a Ruby runtime to be installed separately, you're even losing some of Ren'Py's strengths.

Jake wrote: It sounds like rather than writing an RPG framework for Ren'Py, you're porting RPGMaker to Python to be Ren'Py compatible?

I guess you get to re-use the toolset, but it makes me much less interested in the idea if you're also going to be inheriting RPGMaker's limitations... and if you're going to require a Ruby runtime to be installed separately, you're even losing some of Ren'Py's strengths.

The RPGVX porting is mainly meant as a good starting point for RPGs (RPGVX logic, displays, etc), rather than inventing from scratch. Also, to take advantage of the exising RPGVX resources (community, artwork, etc), rather than starting from scratch on a totally new system. Also, it's intended to be just as much for RPGVX users, as for the Ren'Py users.

But, after that groundwork is in place, you should be able to easily replace individual parts, or add extra features, if you'd like to customize it further. Also, it's not meant to take over your game logic, but rather be an add-on, similar to the Tile/Unit engine. Most likely it will be a set of displayables (based on the various RPGVX screens), and a comprehensive set of game/RPG state data (characters, inventories, levels, stats, etc), that your Ren'Py code can use as needed.

The Ruby requirement, is only if you want to load rvdata files directly from the game (one small ruby script, that demarshals rvdata files, and then outputs as YAML/XML/etc, which the Python code then loads). Basically a quick way to import your RPG maker project files into your Ren'Py project, without running a separate converter tool. It's mostly a conveniance thing. But if you don't like including Ruby, then you have a few alternatives:

- Convert from rvdata to yaml/xml/etc in advance, before distributing your game
- Edit yaml/xml/etc files by hand, without using rvdata/rpg maker editor at all
- Construct game objects in your Ren'Py script directly, without using rvdata/rpg maker editor/etc.

And most likely, also be able to load data from other editors (eg: Tiled), that you normally can't do from RPGVX.

Well, the above is how it's meant to work in theory. I don't know how it will actually work in the end.

wizzardx wrote: Also, it's not meant to take over your game logic, but rather be an add-on, similar to the Tile/Unit engine.

OK, so how would you see the interface between Ren'Py script and the add-on, in this case? It seems to me that most RPGs centre around a world map and/or town/dungeon maps, with interaction coming in the form of shops, conversations with NPCs and battles. Some degree of scripting is required to perform conditional events in the world, town and dungeons, which can't really be done better in Ren'Py-script than other languages; shops can either be boilerplate or custom-scripted, but either way Ren'Py-script doesn't offer much to help; battles are completely outside the scope of Ren'Py-script, so it seems to me you're really just left with NPC conversations... so my assumption was that you'd end up every now and again calling Ren'Py labels occasionally for conversations, with the main driver of the game progression being some other script or just engine+data.

My concern is that since the linear VN Ren'Py-script isn't the driver for the course of the game, you're really going to be scripting most of the important parts of the game in some other language entirely (albeit probably Python), and losing out on a lot of the advantages Ren'Py has (for example, how would rollback fit into this?)... but you're still going to have a few headaches making your stuff compatible with all of the Ren'Py stuff for that relatively small usage.

Not to say that you shouldn't do it - undoubtedly it'll be a useful thing to a lot of people - it just seems to me that if you're not going to be taking advantage of (or able to take advantage of) a lot of the big strengths of Ren'Py, you might as well save yourself the trouble of fitting in with Ren'Py in the first place and write a separate engine, since you're going to be almost doing that anyway.

Jake wrote: OK, so how would you see the interface between Ren'Py script and the add-on, in this case?

This is still a detail I need to spend time researching (how does the Tile/Unit Map handle it?).

But likely for rollback (and game saving/loading), the internal game state variables would take part in it, just like other Ren'Py game variables. Though, I'd need to check how feasible this is, and how other RPG Ren'Py games handle it (are you able to rollback/save/etc during a map, or only in the VN sequences inbetween?

In terms of flow of control, there are a couple of ways it could be done (in theory).

One way to do it, might be to use a similar approach to menus/image maps. ie, the ren'py code knows what events can take place in the map, and then jumps by itself to the correct branch (and optionally returns to the calling Ren'Py code later), depending on variables that get set by the RPG displayable (when the user triggers something). In other words, your Ren'Py script becomes responsible for the scene changes, and glues the different events together.

One downside of that approach, is that it's very glueish, and your Ren'Py code ends up with a lot of if/else/goto/etc, but it does allow the script to retain maximum control over the flow control.

Another method, might be to make it more event-driven, similar to the Tile/Unit engine. ie, you can associate Ren'Py labels with specific map/RPG events, and then when specific events trigger on the map (while it's being displayed), then your RenPy code jumps to a different label, and runs from that point (either with or without a return to the original script location). I need to check how the Tile/Unit engine handles it.

But what I'll most likely do, is try to get a compromise between the Ren'Py flow control, and how RPG Maker RGSS does it.

How RGSS flow control works (between different game screens), more or less:
And then within each scene's controller logic (where a scene is a set of screens, eg game menus, or shop, or the main map, or the title screen, or battle), it handles it's own logic, sets variables (including the next value for the global "scene" variable, to move between game screens), and handles transition effects to go to the next scene.

I'm thinking that each "scene" (set of screens, when the player switcheds between maps/shop/inventory screen/battle/etc), could be a separate displayable.

The Ren'Py logic would setup any callbacks it needs to (eg: within the map events, or RPG VX-styled common events), and then just loop for as long as it wants to, and letting it's callbacks, and the scene control logic handle the main details of the game. But at any point (eg: in callback renpy script code), it can decide to stop the looping, and go back into a regular (mostly) linear Ren'Py script format.

With this type of logic, then you should be able to easily rollback to either the last screen change (scene), or individual lines within your callbacks script functions.

So, while the RPG library does take some control, it's only for as long as the Ren'Py script wants it to. So eg, you could run your whole game loop using the RPGVX-styled scene loops, or just have it for portions of your VN, and use traditional Ren'Py code for the rest of your game.

As for the logic in the scenes/windows/etc themselves, they would look as close as possible to the RPGVX ones, but game developers can make their own scenes/windows/etc, just like a RGSS scripting environment except, in Python, not Ruby).

Also in terms of event coding/flow control, I'm considering letting the RPG VX-edited events run, if they were added in the RPGVX editor (to individual maps, or to the common events). ie, instead of needing the all the flow control to be within the Ren'Py script callback functions. You'd also be able to call python logic, or Ren'Py labels, by adding them in the RPGVX event editor (in the advanced/"run script" command).

Well, those are the main things which come to mind, but I'll need to see what works best in the Ren'Py environment, when I work further on this.

Sorry for the double post (I'm not sure what this forum's policies are on it).

I've been working further on this (as a proof of concept), and here's how the status screen looks at the moment:



This basically demonstrates loading of the RPG Maker VX rvdata and image files in a pygame script (based on the RGSS code, and re-implementing some internal VX logic), and rendering a window close to how VX does it.

Most likely this system (which I'm calling PyRGSS for the moment) would initially run as a renpygame minigame, until I figure out how to integrate it better with Ren'Py scripting (similar to how the Tile and Unit engines work).

Also, I have been discussing some details further on another forum, if you're interested:

http://artonelico.isisview.org/viewtopi ... 40#p367745