As unsure as I am on Jung's psychology, I am finding odd inspiration from dreams recently. Maybe this is because I'm paying more attention on some level. It seems like I have a lot of my better aha-type-ideas (as opposed to deliberative-judgements) when I'm asleep, and that the random bits of scrap paper (and occasional journals) and pens I tend to keep near my bed are among the most important things I own. Anyhow, thanks to a bit of encouragement, I think I'll "teach" a "class" next semester, whereby interested folk (should I get enough) will dust off the dust on MoLD, a project I had about five years ago to make a roguelike, and try to progress on it. The state of the code, last I saw it, was at an interesting state - it's enough to do "something", but not enough to do a lot. My skill as a programmer has improved significantly over the years, and there are plenty of ideas I have on improving code structure. There are still several things I don't know how to do, although fortunately there are some other codebases that do those things that I am familiar with that we could look to for inspiration.
I suspect that people might get good exposure to the following things that they might not be familiar with:
- Programming for curses (a nongui interface toolkit) - I implemented the basic interface in this. My code could be improved in many ways - I know curses but am by no means an expert.
- Programming for SDL (it would be cool if someone could whip up an interface)
- Object-oriented Perl - the code is kind-of OO.
- Refactoring existing code - I'd like to refactor the whole thing. Refactoring is one of those programming topics that generally isn't taught in school, and it's something most programmers will eventually find themselves doing.
- Roguelikes. Most people haven't played them, but they're an awesome game genre. There are a number of traditional challenges in their implementation.
- The Subversion revision control system (although I imagine CMUfolk actually have a decent chance at having used this, actually)
I am not sure on the following issues:
- I'd like to change all the code from argument-list passing to named-parameter passing. Should I do this before "class" begins? It might be a good refactoring experience/warmup for everyone, but it also would lock most people into doing that until it's done.
- Would it make sense to introduce a PostgreSQL dependency into the codebase? If game data were stored entirely in a database, it would simplify a lot of things, and people who don't know databases could learn how they work in the class too. At the same time, it introduces yet another dependency, and makes gamefiles less portable.
- Should I use the last codebase I did or the last one in CVS? Someone else took over after I became busy, and it looks like they ran with the code for awhile. Their code may be better(?), but I'm definitely not familiar with whatever changes they made. Also, should I get in touch with them?
- Should we use sourceforge? If so, should we work on the main tree or create another branch? Should .. well, if we do use sourceforge we should arrange for the repository to be ported to subversion. It's nice to be civilised.