Hi all,
My wife and I are trying to get a little joint project going. It started as a 7drl, but because of a pretty terrible week we didn't get very far.
For the theme, we decided on something we are very passionate about: Hayao Miyazaki's masterpiece, Kaze no Tani no Nausicaa, published in English as "The Valley of the Wind" or "Warriors of the Wind" or some such nonsense. It's a wonderful anime that foregoes R-rated content, boobs of infinite size and kinky dresses for a beautiful, meaningful story. I usually like to say Nausicaa was my first love, but my wife doesn't find it nearly as fun
For mechanics, we decided to do something close to a roguelike which has non-complicated graphics stuff. We're using Python 3 and PyGame. PyGame is a little too lower-level for my liking, but I can't find something which is higher level and not horrible to get working with Python 3.
It's still really early in development, but here's a tiny screenshot. I'll explain what's behind it in a second.
While it does look simple, here's what we've gotten properly implemented so far (in a way that's extensible, hopefully moddable, and so forth):
- Items are read from an xml file and a spritesheet. It's *really* easy to add new properties or graphics to all sorts of objects, and then use them from within Python.
- The input system is up and running. It reads keybindings from an xml and transforms key press events into "in-game events", such as "ACCEPT" when you press enter/return, "EXIT" when you press ESC, and so forth.
- A fairly extensible GUI system (no mouse, sorry, perhaps later) using an input stack that propagates events downwards if they haven't been consumed. This has been used to implement lists, direction selectors, etc. The several GUI elements (lists, etc) have callbacks so that you can use them for multiple uses (a selector for a set of items can be used for pickup, drop, examining, throwing, etc)
- A nice activation system, where items get activated through callbacks as well. Items set their own callbacks, and as the hero moves, time passes. Once it reaches an activation/event, it gets executed, and in turn it might spawn other activations further down the line, or immediately. The crops you see in the image, for instance, will require care (that's an activation that reduces crop care every X time steps), and will also grow into new stages (activations that happen in longer time-scales). This information, again, is mostly all read from xml properties, without me having to set up specific classes to declare lots of variables for all the things in the XML.
- Basic actions are done, such as movement, pickup, drop, opening and closing containers (which make their items visible), etc etc, though some testing needs to be done.
- Map scrolling, so it can be bigger than what you see.
Next up, I am planning to implement:
- Procedural village generation, to have several crop sites, trees, houses, and villagers.
- Villager AI, so they take care of crops, etc.
- Splitting the game into seasons, and each season perhaps the hero will be able to assign how many villagers do what tasks.
- Combat, eventually
Now, I would very much like to keep the game as close as possible to the atmosphere of the movie/manga. All the ideas I am coming up with, however, will make for an insanely depressive game. I would love feedback and other suggestions (if you haven't watched the movie, do yourselves a favour and watch it!):
- Events - every "season", different events can happen:
- Insects sometimes travel to the village. Ideally, you'd get rid of them without violence (how, not sure). If you don't, you will enrage the forest and more insects will come. They will have a certain "rage" level, and they will leave once they have done damage corresponding to the rage level. This includes killing villagers, so your village gets progressively smaller and smaller as people die...
- Spores, either from insects or just drifting with the wind, will sometimes come into the village. If not taken care of, they will kill crops, grow miasmas and make people go sick and take over the village. You'll have to burn them.
- Enemy nation attacks/visits. They will land, and they might be militaristic or not. Defend or trade or pay taxes or something. Not too sure about this.
- Village management: how many people should tend the crops and care for them, how many should search for spores, search and harvest chico nuts, build buildings, draw water, etc.
- Adventuring: more classical RL behaviour. You should be able to travel to or find several locations. Abandoned villages, half-taken over by the toxic jungle, wrecks from past civilisations, the toxic jungle itself... food for these adventures are the chico nuts you have people gather, so you have limited exploration time. You might find ohmu shells, interesting artifacts, raw materials, etc. These should allow you to make better tools for villagers and so forth. Of course, killing insects should always be a bad idea, but they are not initially aggressive. Perhaps certain events might make them aggressive, and the more you kill, the more dangerous is becomes to stay in the jungle.
These are just some loose ideas. They shouldn't be overly difficult to implement, but they'll take some time. Either way, I'm not sure if they make a good game. I mean, right now, with these mechanics, the goal is just to survive as long as possible, as you lose people more and more to attacks... I don't want it to be a fixed story adventure that you play one time, or I could try to follow he storyline of the movie...
Any ideas are awesomely and greatly appreciated!
And for whoever insists on using C++ and whatever, you can have a look at the code
here. In particular, look at the
Entity Manager which reads from
entities.xml. It's set up so the content of entities.xml dynamically sets what variables are available in each class. Then you can just use them in the code without worrying.
I've tried to keep the code pretty commented, and I would love feedback on the GUI system, the way I'm handling events and so forth