?

Log in

No account? Create an account

Previous 10

May. 7th, 2014

bumbershoot software

New Inform 7 release

The interactive fiction language Inform 7 just released version 6L02, which makes a lot of changes internally and tightens up the syntax some. Of my four extensions, two continue to work out of the box, but Reactable Quips and Quip-Based Conversation both need minor updates to compile.

I've released emergency patches on my IF site for now, but I intend to do more thorough updates of all of them later to make them integrate more fully with 6L02's new features (most notably library message extension and adaptive text).

Most of the things I've been working on are now being published over at Bumbershoot Software.

Nov. 20th, 2010

time lord

IFComp 2010: Complete!

As I mentioned in my last post, a month and a half ago, I wouldn't be blogging the comp. That's because I entered: my entry, Flight of the Hummingbird, ended up placing 8th - and against extremely respectable competition. I'm pleased.

I've also written a complete set of IFComp10 reviews and posted them at my main IF site. I'm mostly wearing a pretend judge hat for them.

As for the comp as a whole? A lot of reviewers observed that this was a year of mostly unassuming competence, and general solid polish, but that there were no wild, mad experiments. I agree with the first few points, but will disagree a touch with the final one.

As for the first part, I was far from the only person to think that no games rated a 1 this year, and this is the first year since detailed breakdowns have been kept that absolutely no games got a modal score of 1 (that is, every single game got more of some other score than they did 1s). The winner, Aotearoa, did not get a single rating under 5, and has the lowest standard deviation in scores in any top-ten game since standard deviation has been recorded. Meanwhile, take East Grove Hills, which placed fourth-to-last, and compare its raw scores against the 2008 competition, and it's at the 50th percentile exactly. (Its score puts it between #17 and #18 in a 35-game competition.) Even the low end this year always had something to recommend it, even if it was only Maniac Mansion nostalgia.

As for the final point... OK, sure, there was no Lost Pig this year, nor Violet, nor indeed even a Legion or a Delightful Wallpaper or a Deadline Enchanter. But to say this wasn't an experimental comp is to ignore a great deal:

  • Aotearoa includes namable NPCs and extends the keyword/command hybrid play of Blue Lacuna.
  • Oxygen includes strategically reactive NPCs in a general dilemma situation.
  • The Bible Retold: Following a Star uses an unusual-for-IF mainline-plus-sidequest structure reminiscent of console RPGs to fit the main game in two hours while allowing a wide range of extra content to be available. It also shows off a wide variety of technical and parsing tricks.
  • Its much smaller companion piece The Bible Retold: The Lost Sheep includes a WALKTHROUGH command whose output is computed on-the-fly from your current location and game state.
  • R was fabricated from scratch with a new engine for creating Scott Adams data files.
  • My own Flight of the Hummingbird was in large part an attempt to make platforming mechanics actually work in IF as IF (as opposed to, say, Sylenius Mysterium or the parody Metroid IF).
  • Gris et Jaune is a hackneyed genre premise meticulously researched to the point that it is entirely unrecognizable as genre, and is instead a fantastic period piece. (This is one where you may want to hold off on this one until release 2, though.)
  • Under, in Erebus's core mechanic has been seen in the IFComp before, but it was thinly implemented and basically useless. Erebus provides scores of possibilities and is packed with easter eggs for a game-space-exploration-oriented player. (A second release is in progress at the time of writing and drastically improves the user experience.)
  • Leadlight is a vastly elaborate retrocoding project, and notable for this alone, despite also being an eminently playable RPG-style IF. (A post-comp 1.1 release is already out and recommended for people just getting to it.)

So, OK, fine, maybe there wasn't any mad IF science this year. But I'd say we managed a pretty solid set of scientific conference proceedings.

Oct. 2nd, 2010

at ease

IFComp 2010

It's IFComp time again. This time last year and the year before, I'd do running reviews in this space.

This year I will not, instead releasing reviews at the end of the judging period in mid-November.

That's because I'm an actual competitor this year, and the conflict-of-interest rules preclude me from doing this.

The comp looks like it's going to be awesome this year, though, based on name recognition[*] alone; I am unreasonably excited at this point.

[*] A quick scan of other review sites finds a split between "Wow, look at all these old names coming back" and "who the heck are all these nobodies?" - this seems to depend on which part of the last decade you were paying attention to IF in. A few very old names are back, and there are big chunks of authors from the 2005-2007 era, and a good chunk from 2009.

Sep. 18th, 2010

bumbershoot software

Playing around with new systems

I've recently been messing around with the Game Maker 8 system, to see what the state of play was for action-style games that are targeting non-programmers.

Short form: I was pretty impressed. I'm no longer really surprised that Iji and Spelunky could be written in it. But it's not a 'non-programming' system by any measure, other than that it tries to be discoverable.

In an effort to make more sense out of it, I took on a minor project with it to put it through its paces: Imperial Solitaire. Behind the cut, my development diary for it.

Dev Diary for my "Imperial Solitaire" projectCollapse )

This was pretty educational in terms of getting a grip on the corners of the system. I didn't come close to exhausting what it can do but with the familiarity I had with it I can make my judgements on it now.

  • If you aren't a skilled developer already, this is an excellent system to work in. It's got a surprisingly good engine paradigm - if you move on from GM8 to some other development system, you'll have picked up good habits from GM8. It's got a lot of training wheels when you're just starting out, but it'll grow with you too. It's got a very active user community. Stuff you build with it is very easy to distribute. And if you go Pro with it, it's way cheaper than, say, a Flash development kit.
  • If you've done some programming but don't have much experience with games, you should at least look into this. Writing an engine is Work, and if you go this route, along the way you'll have something you can show off and test and tune. Also, above the "teaches good habits" and "grows with you" points above; it'll likely stay out of your way, and if you find it isn't, the odds are quite good that it's right about how your code should be organized.
  • If you're already experienced in 2D game programming, there's not a whole lot here you haven't seen, and the reasons to not use this system are more likely to actually swing the pendulum the other way. I'll get into those below. You might still want to poke at the free version to see what it's about, and it could be useful as an initial prototyping tool.

If you're planning on rolling your own, you'll also need to be able to meet or beat the basics of what GM8 gives you "for free". To wit:

  • Animated sprites with adjustable center points, and game objects that can share them or change them on the fly.
  • Event-based game architecture that let your game interact safely with the OS.
  • Not mandatory, but probably always a good idea; an ability to replace event handlers piecemeal or wholesale.
  • Frame rate throttling, and an ability to tell if you're overloading the system.
  • Fire and forget sound mixer that can handle sound effects and music without much interference.
  • Collision detection; most serious games will custom hitboxes as well, as bounding box and pixel-perfect are both very rarely actually the right answer.
  • Viewport control; the screen will generally be much smaller than the playfield, and you'll need to handle this sensibly.
  • Resource bundling. You don't have to cram everything into the EXE the way Game Maker does, but you'll probably at least want the equivalent of ZipFS or other data agglomeration systems to avoid wasting disk space on FAT32 or whatever.

That's a lot of work, so if you don't have a bunch of that already handy, using GM8 means you have a bunch of work already done for you. So, why wouldn't you use it? There are a few reasons.

  • It costs money. It's not uncommon for a dev to insist on a $0 overhead on dev tools, especially for prototypes (though the Lite version may still be handy there.)
  • No native support for advanced sound formats, noticably MP3 and Ogg Vorbis. Thanks to limited support for extension DLLs, there are ways around this: Hero Core uses FMOD, while Spelunky uses an extension called "Supersound". This could be problematic in general, though, because...
  • It's not cross-platform. The system is Windows-only right now and while a Mac version seems to be in the works, it doesn't look like there's parity, and things like Supersound might not port. If you want to target Linux you're out of luck, so going full tri-platform means you'll have to roll your own.
  • It looks like most resources are going to be loaded into memory all at once at game start. If your game is large enough that it should really be using resource overlays, you may have some trouble. I think this is still possible, but I think it only works in the Pro edition so I can't evaluate it.

Those are enough that (given my own background) I probably would not personally use GM8 for anything beyond toy projects; but I know enough about the general area to know a good product when I see it, and this is a good product. Kudos to Yoyo Games.

Nov. 12th, 2009

at ease

Go (not the board game)

As you may have heard, a few days ago Google released a new programming language that they'd been developing for awhile. And by "they", I mean Rob Pike and Ken Thompson, both of whom were instrumental in the creation of Unix, its predecessors, and its successor. They also invented UTF-8. So, you know, there's some reason to pay attention.

As it happens, Pike gave a talk about what I suspect was the early parts of this project in a CS 343 class I took at Stanford as a grad student not that long ago.

If that's true, the answer for "why a new programming language?" is pretty clear; Google wanted something vaguely Python-like for writing their services in, but Python's famously horrible handling of concurrency and multithreading meant that it wasn't really appropriate for this.

Their new language, "Go", uses an old but reasonably well-proven mechanism for multithreaded communication. Despite being well-proven, it's almost never actually used, so in order to make this a proper language primitive they basically needed to write a new runtime from the ground up anyway. And once you do that, you might as well redesign the type system and so on and so forth, and pretty soon you have an entirely new language.

I figured that as something of a language geek I'd look at it and see what I could do with it. As it happened, I did have a project that could use it; while I was extracting karma information from Ultima IV save files (see my previous post for why I was doing that) I was using an ad-hoc Python one-liner for it:

struct.unpack("<8H", file("party.sav", "rb").read()[326:342])

Go advertised itself as being a systems programming language primarily, and binary unpacking is the sort of thing that one would normally use C for. Writing a somewhat more detailed savefile unpacker in Go might let me see more of the language in action.

It turns out that I didn't need a whole lot for this: the source code, u4scan.go, didn't really do much with the type system that a C struct couldn't handle just fine.

That said, I did get to see enough to like the type system a lot. I've never been much of a fan of OO or inheritance - my designs rely heavily on composition and what the Design Patterns guys would call the "strategy" pattern. Which is to say, my design sensibilities are much more in tune with ML or Haskell; I'm happier thinking of verbs that can act on various different nouns instead of thinking of nouns that carry verbs with them. It's all the same in the end (you get a 2D matrix of verbs and nouns), but it does influence what's easy to express.

Go takes Objective-C style "protocols" - types that are simply collections of the methods defined on an object - and pushes them as far as they will go. The result ends up bumping up against Haskell's typeclasses, which is about the strongest praise I can give. The type guarantees are much closer to Haskell's than ObjC's, though there's more declaration that needs to happen first. Go has some type inference, but it's not as good as the best inferrers. Nevertheless, it looks like an excellent combination of duck typing with static typing - ObjC's was far too easy to break.

Unlike Haskell, it's possible to break it in Go; the binary.Read function I used in the savegame scanner was able to unpack a binary file into nearly-arbitrary structures. (The requirement is simply that they be fixed-size and thus properly representative of a chunk of binary data.) Its reflection capabilities handle the rest. That made the meat of this project refreshingly easy. (I'd actually written some code using the unsafe portions of the language to convert floating-point numbers to and from their bitwise representations; it turns out that while it's not documented as being able to do this, the binary encoding package can handle floats fine.)

Go's ObjC-like use of protocols as the fundamental unit of typing extends to being able to add methods to arbitrary types (even primitives!) outside of their nominal definition, which means that I can organize things in the data-directed manner that I prefer.

As a professional C++ programmer, Go's declaration syntax gave me trouble until I realized that it was actually Pascal syntax with most of the punctuation removed.

So, yeah, as a language it's fairly nice. As a programming environment, however, there's almost no need for non-language-geeks to mess with it. It's simply not there yet. It's less there than Inform 7 was in its first public beta:

  • No foreign function interface. This would be less of an issue, but...
  • No I/O more complex than sockets and files. Interactive user interfaces aren't really in the cards.
  • No Windows compiler, since Google doesn't need one. All binaries are Linux and Mach-O (Mac OS X).
  • Even on Linux and Mac, the "real" compiler is a variant of the Plan 9 From Bell Labs compilers and so they don't use any runtime your home system will have; as a result, even Hello World is a 580KB binary and they only go up from there.

I suspect that if the gccgo subproject (which ties, unsurprisingly, into gcc's backend) gets some development, it will solve the last two problems neatly - if it works on gcc, it should work with MinGW as well.

But yeah, as it stands, fun to read about and maybe mess with, but unless you're actually part of the core development team, I can't see it being used for anything serious by anyone else for awhile yet.

retro

Hacking the Virtues: Becoming the Avatar in Five Easy Steps

I've been on an Ultima IV kick recently, since I'd never really gotten around to beating it as a kid.

If you're unfamiliar with the game, Ultima IV is unusual in that there's no particular Final Boss whose rear end you need to kick; the goal of the game is to become a paragon of Virtue and then collect and wield various mystical items to cement your status as the Avatar of the Virtues.

As you may have guessed, this also means that you get to run rampant if you decide that Virtue is for little people, and, indeed, the accidental moral of the story is that the correct way to become a paragon of Virtue is to lead a highly profitable life of crime and then use the proceeds to finance various good works.

I hadn't realized that as a kid, and so my playthroughs tended to end with me getting lost, trapped, or otherwise incapable of meaningfully continuing because my foes were far more powerful than I was and I couldn't gear up enough to take them down. I had not learned from the example of the Saga of Steve the Avatar. This is the tale of Steve, who becomes the Avatar and then has various further adventures (the saga continues through Worlds of Ultima: Martian Dreams, Ultima VII Part 1: The Black Gate, and Ultima VII Part 2: Serpent Isle) despite being a complete and utter sociopath. And yet, paragon of Virtue. Being the Avatar is awesome.

After having this epiphany, I resolved to try to set right what had once gone wrong, by going wrong where before I had gone right. And it worked pretty well, except that I noticed that my Virtues weren't quite behaving the way I'd expected them to, given what I'd seen in the Saga of Steve. So I whipped up a little program to study my save file and give me precise Virtue information as I acted. Once I had proof stuff was wrong, I went sourcediving. This is what I found.

Cut for length and spoilersCollapse )
Tags:

Oct. 17th, 2009

at ease

Michael Martin reviews the 2009 IFComp: Part 3 of 3

Previous installments include Part 1 and Part 2.

This final installment provides reviews of The Hangover, Grounded in Space, Yon Astounding Castle! of some sort, Rover's Day Out, The Grand Quest, Spelunker's Quest, Condemned, and GATOR-ON, Friend of Wetlands!.

The observant among you may have noticed that I have no "Taking out the Trash" entry this year; the overall quality was high enough that the number of "What on Earth were you thinking when you thought this was ready to submit" entries was quite low indeed.

Furthermore, while the average scores I gave this year were somewhat lower than my normal average, within each tier (waste of time, competent-but-unimpressive, and worth-pushing-on-others) there was a strong bias towards the top of the range.

So it's been a good three weeks all around. Thanks, entrants. Even the ones whose entries I savaged.
pwn3d

IFComp09 reviews: GATOR-ON, Friend to Wetlands!

So long, Pyth-nor!Collapse )
Tags:
doom

IFComp09 reviews: Condemned

It would be fairly embarrassing if it turned out that the author is actually, like, 40Collapse )
Tags:
retro

IFComp09 reviews: Spelunker's Quest

You don't need a cave. All you need is a rock.Collapse )
Tags:

Previous 10