The glutton branch (SCI01,SCI1 etc. support) seems to be coming along nicely, meaning that we may have some parts of Quest for Glory 2 playable in the near future. I guess it's time to start worrying about handling palette effects now-- they're already present in QfG2 (EGA-- using a 16 color palette selectable per-image, this was discovered by Lars Skovlund), but they're likely to become more relevant wrt performance in the VGA games (back in the days of color index modes, those were a great way to get certain kinds of simple animations cheaply).
Using per-image palettes sounds like a great way to re-use graphics-- consider, for example, an RPG allowing you to configure hair color, eye color, and complexion. Of all the (graphical) RPGs I've seen, only Ultima Online seems to take advantage of that (although I'd expect other online-RPGs to do the same).
I've been wondering about this for quite a while: It seems reasonable to be concerned about type systems restricting both the expressivity and the effectiveness of programming languages-- after all, the security checks they offer do restrict what you can express, in a way. However, given a statically checked typesystem with (bounded) polymorphic parametrism (offered by safe languages such as Haskell and Modula-3, as well as by mostly-safe languages like Eiffel and the upcoming Java-with-Generics) and ad-hoc polymorphism (aka subtyping-- present in all "object-oriented" languages) (I'm not sure if the latter is all that useful if you have the former already, BTW), are there any practically useful constructs that are particularly cumbersome to express? (You can always express all of them by defining an unsafe interpreter on top of your language, of course, but I'd consider that to be a good example of a cumbersome solution ;-) I can't really think of any, but that may be just because I'm too used to thinking within the restrictions imposed by these type systems (I found it similarly hard to understand parametric types at first, until I used them for a little while and then stumbled across an... opportunity to experienced what container classes (textbook example for using type parameters) look like in languages that only do ad-hoc polymorphism).
So, any ideas?
Types, Proofs, and Books
So the CU library doesn't have Girard's "Proofs and Types" (which is probably what chalst was referring to), it's out of print, and it's not exactly the kind of book you're likely to find in a used-book store. As a relative novice in this area, I'll have to look for a different starting place-- the CiteSeer is unlikely to spit out entire books. Reading papers and articles is certainly helpful, but I'd prefer some solid foundations, in order not to miss out the "well-known fundamentals that hardly deserve mentioning". Any suggestions?