Crwth's Miscellany

UO Reminiscing

2010-07-23T16:07:00.000-07:00

I can't help myself -- I love Ultima Online. I'm not currently playing, though, because I subscribe to the update notices, I get told when a new patch goes in and get tempted EVERY TIME to renew. Luckily, I'm conscious enough of my lack of free time that I know I wouldn't be able to do a subscription fee justice.

UO is what drives a lot of my programming projects, too, no matter how hard I try to distance myself from it. When trying to work in Metaplace, I was more often working on UO-like functionality or a UO world than not. When working on my Windows Phone 7 development, I find myself making a UO-like game to learn XNA. And of course, when I work on MMORF, the whole driving motivation is to make something that can run a UO world.

Lately I've been interested in the early days of Ultima Online; I was there in the first month or two of release, but missed an Alpha or Beta testing, back when the world was young, broken, and in transition (not to say that a live MMO isn't always in transition, but...) there are some great screenshots of a world that I never got to see, but it's the handful of anecdotes out there that are really good, ones that detail how the rules worked -- or how the rules didn't quite work -- in the early days.

There weren't tons of these to be found on the old Alpha/Beta archive sites that I found; they were mostly about screenshots. But it was while reading an old post-mortem on Raph Koster's site about UO that I caught reference to where it had been originally posted: the old rec.games.computer.ultima.online Usenet group! This has led to a treasure trove of opinion from 13 years ago, which has unfortunately sucked me in completely. I'm only on the second page of posts and I've already found a few priceless gems, which I'll share with you now:

I started in Yew and was swarmed by  NPCs wandering all over the place.  Several beggars followed me wherever  I went.  Most of the time, I couldn't move (server kept yanking me back  to the same place when I tried).  Eventually, the beggars cornered me  against a building and the coast and would not budge.  I tried  everything I could think of ("Look! Isn't that Lord British?") but they  would not move.  I had nothing to give them but the edge of my dagger.  Of course, after one swing a nearby guard (there were dozens) "freed" me  from the beggars. How thoughtful. :)

I went to a farm just outside Britain to see if I could make some money picking crops.  I couldn't figure out how, so I went into the farmhouse to see if I could find any farming implements.  I found a dead body lying next to a pitchfork with two guards standing nearby and thought better of it. :)

They happen to be by the same author (Dave Erazmus), so I'm going to have to watch for his "future" posts to see what other gems he might have posted.

Visual Studio

2010-05-20T09:26:00.000-07:00

In a complete one-eighty to what I said in my last post, I've moved to Visual Studio 2010 Ultimate for all of my C# development.

Because I've started some Windows Phone 7 development, using Visual Studio is pretty much required because of the need for the emulator. Since I'm learning my way around VS for WP7 development, I figure I might as well go whole-hog with it and use it for everything, to really get used to the environment.

It also helps correct one of my biggest problems when coding for myself, which is not using revision control. I just can't seem to get myself to do so when working on a project by myself (and thus without any issue of change collisions) and with no one to answer to about changes (because the projects rarely go beyond my own use). For this purpose I'm learning to use Team Foundation Server, which also provides me with a project tracker, something I should train myself to use more often as I expand my projects and find missing features and bugs.

I've made a little more headway on my UO asset stripping tools, adding them as a proper project in Visual Studio and expanding the set of data files they process. Now that I've forsaken Mono (for the time being, anyway), I have the full strength of .NET, Windows Forms, Silverlight... any method I like for developing a better-than-command-line interface. (Okay, okay, Mono supports almost if not all of these, but this is the "proper" way to do it!) And, I still hate to admit it, but I'm getting more and more used to Intellisense. And Expression Blend... pretty slick!

A month later

2010-03-14T12:11:00.000-07:00

I'm making good headway through reading the C# 4.0 in a Nutshell book; some might say that it's not really a front-to-back book, especially in the later chapters where it's definitely reference information, but I find it a good way to get a sense of the capabilities of a system/API/library to go right through.

I'm loving C# 4.0. It has some really good advanced features of "modern" languages that make it very powerful, such as delegates, lambdas, generics, operator overloading, dynamic lookup, named parameters, variance... yes, I'm aware some of these features existed in C# before 4.0. And many of these features are available in other languages, but not usually ALL of them. Having some of my favorites from C++, Java and Lua, all bundled together, makes for a delightful language. Many of these features go very well with the way MUDs/MMOs work, with the idea of object trees, feature inheritance, scripting events and the like: if you "use" an object, the engine just has to call the object's use() function; if it doesn't have one, then nothing happens, and if it does have one, it just gets called. No having to check the object type, no need to check for member availability, no need to cast -- no need for the engine to ask "is this a useable object" at all. But now I'm encroaching on the content of my other blog.

I've just finished the first step of the asset-stripping project; I can now pull out a terrain tile and save it to file. This is something that was much quicker to do in Lua and Go, mainly because of fighting with the build environment. Even though I have access to C# via Visual Studio, I'm a die-hard command-line coder, and am much happier (and much more productive) when using emacs and make. Thus, instead of just writing the code that I've got in ten minutes and having it work, I've been fighting with getting Mono, the free implementation of C#/.NET, working for me. Some of the problems were on installation, and some were on CLR usage that looked like installation issues until Google saved the day.

In the end, though, having the full .NET library available makes things so much easier. In Lua, I ended up dumping the sprite rendering onto ImageMagick, instead of trying to find a decent PNG library. In Go, PNG support was provided with the libraries, but all of the explicit typecasting really made for an unenjoyable programming experience. In C#, once I got around the compilation issues, it was nearly trivial, with zero-indexed arrays (unlike Lua), and natural type conversions.

My next step is to get Mono to display the graphic for me, instead of just dumping it to a file; this will be the first step into writing an InsideUO clone, and my first step towards being ready to write a test game client for MMORF.

See sharp

2010-02-17T08:12:00.000-08:00

I got my copy of C# 4.0 in a Nutshell yesterday, so today I start my first C# mid-sized C# project as a way to learn the language.

The reason I'm learning C# is to use it as the main language for my MMORF project. I chose C# because... well, it's similar enough to Java as to make it not completely foreign, as well as to leverage a mass of .NET libraries. Why .NET? Because it's about time I learn it. Why not Java instead? Because it's about time I learn to program for Windows. Why not Java instead? Yes, yes, Java programming can be "programming for Windows", but it's about time I really learn how to program for Windows. Besides, C#/.NET is still useful, via Mono, on other platforms, so it's not like I'm abandoning the rest of my environments.

The mid-sized project I'll be writing will be an asset grabber from the Ultima Online 2d asset files. Pulling out assets for the newer Stygian Abyss 3d-style assets would also be interesting, but I'm not aware of any documentation on those file formats (not that I've really looked), but I am quite aware of documentation on the original datafiles, thanks to the early work of Ultima Online hackers like Heptazane/Alazane, Cironian and others.

This project is one I've written twice before, first in Lua to learn that language (for eventual use in Metaplace, mainly), and also to learn Google's Go language. An asset grabber requires you to learn file access, and random access at that, as well as binary data manipulation, low-level data structures, buffer management, data merging and image generation, all the while working/fighting with the language's underlying type system. Lua was NOT the language for such a project, so it was very educational in making it work; Go was better suited, but the project greatly highlighted Go's strong type system, especially when coming from Lua.

The reason why I choose to write this project, yet again, is because I plan to take it a little further than I have in the past. Previously, it ended up as a cobble of command-line tools for stripping out specific sprites, animations and map data. Since I'm taking on this whole Windows programming thing, I think it's about time I get out of my command-line world and start making pretty graphics and windows and such, something that I haven't done for a long time, and even then, with trepidation under Java. Learning the Windows way of doing things is long overdue, so beyond just an extractor, I plan to make it a viewer as well, akin to the InsideUO tool written by Alazane.

And, of course, the end result -- the purloined UO assets -- are really good placeholders when developing a rudimentary client for MMORF; in fact, if you've read that project's blog, you'll know that UO is a large inspiration for me, and one of the targets that MMORF aims for: the ability to replicate that environment. That will include handling a map like UO's, and thus pulling out that map data -- for test purposes only! -- will be necessary.

As part of this C# education, I also plan on taking a look at the XNA development environment, which seems even to me to be odd, given that I own a PS2, Wii, PS3 and PC, but no Xbox/Xbox360 nor a Zune. Of course, there are also runtimes for Windows, and XNA looks to be a good platform for pretty rapid development of some pretty indepth graphical clients. Of course, many will wonder why I don't use Unity instead, and I'm not really sure, except that perhaps it's getting TOO much attention lately, and I'd hate to jump aboard only because everyone else is. Then again, it might be so popular because it IS the better way to go. We'll see.

None of my previous incarnations of the UO asset grabber ever made it beyond my own harddrive, so here's for hoping that this iteration becomes something useable enough that I might actually post the code somewhere.

Focus!

2010-01-26T14:18:00.000-08:00

I haven't spent any time looking at Google Wave in the last few months, not as a user or as a developer. This is not because of a lack of interest, but a lack of time, and as a recent conversation on Twitter has reminded me, I really need to focus my attention to few projects, so there's a chance that any of them get done.

With Metaplace gone, a big sink in my free time vanished, yet I find it hard to put my finger on what has filled the void. My desire, however, is to make some progress on my MMORF project, so in theory, that's where I'll be posting - more often than here, at any rate.

This blog, as the name suggests, will still be a good place for me to dump my thoughts that aren't related to that project. And, since I know I won't be able to stop myself from having wandering thoughts, this blog will still likely see activity.

Genealogy

2009-10-27T18:35:00.001-07:00

One of my many hobbies is genealogy. Over the years, I've sampled many of the various software tools for tracking genealogical information, and while each has their good features, none of them really provide everything you need. I've been part of various mailing groups that have discussed better ways of storing such data, have seen some interesting attempts, but still feel that there's room for improvement.

Perhaps Wave is suitable?

Genealogy is inherently hierarchical - people have children. Replies fill this role nicely. The other relationships, marriage and siblings, are another matter. Wave blips can be at the same "level", so we can perhaps use that to represent a marriage. But if we have a number of children under a parent (most likely their mother, for biological reasons), then they, too, will be at the same "level", so will look like they're spouses, not siblings. And adding those siblings' spouses just complicates the issue even more.

So perhaps individuals can't be represented as blips, but instead relationships should be. The Wave would contain a blip for each marriage, and a blip for each parent-child relationship. Sibling relationships would be assumed/deduced. The question then is how are the individuals represented? As replies to top-level blips? Perhaps, but individuals can appear in more than one relationship -- their own child-parent relationship, as well as their marriage(s). Does Wave support links between blips? I don't know quite yet. Do we link to a completely different Wave? That gets unwieldy if every individual is its own Wave.

Okay, so we haven't figured out this quite yet. Do we abandon the idea? Not quite yet. It was, in fact, the other bits of genealogical research that first came to mind when I started playing with Wave.

Citations are a big part of responsible genealogy. It's one thing to record the relationships that you discover through your research, but recording your sources is very important, not only for yourself, to verify data and reaffirm old research; but also for others to whom you provide research results -- they should be able to trust your information, and being able to look up your sources goes a long way to that. Source notes can simply be replies to the data itself, whether it's a claim about a relationship, the date of it, or any information recorded about an individual.

Along those lines, conflicting data can also be recorded via a reply, such as birthdates that disagree, or even birthdates that agree from differing sources, helping to provide extra proof or confirmation of one possibility over another. This is more of a research tool than a research result; it allows you to keep track of every possibility mentioned, to help you match up with other discoveries.

Suppositions, too, can be recorded as blips, with the reasoning behind them attached as one or more replies. This is much more preferable to adding a relationship or data that was based on supposition into data without marking it as such, which I've found in my research; you find some data with which you want to leap to a conclusion, and then find someone else's research that also reached that conclusion: that's a false confirmation of your own conclusion, and thus you feel justified in making the conclusion. And if you yourself don't mark it as just a supposition, but instead just add this "fact" to your own data, you, too, are going to further this false confirmation if your genealogical data goes public. Most genealogical software doesn't support marking facts as supposition, and thus Wave can contribute to genealogical research in this manner.

And finally, to-do lists and general research notes are another good candidate for replies, letting the researcher make a note of future research directions based on an individual or relationship, or overall notes about websites to reference, contacts made, and overall notes about your research path.

I'll be investigating whether Wave can be utilized for the genealogist's new tool, but as I do, I'll be thinking of that aspect of Wave that I didn't even touch on -- the collaborative nature of Wave, which would allow multiple researchers to contribute to one single body of genealogical data.

Using Google Wave

2009-10-09T11:27:00.001-07:00

I've been playing around with Wave, mostly on my own, trying out different ideas about the nesting of the different blips. Granted all I know about using it is the WYSIWYG nature of the web client and the 80-minute video about it at Google I/O, so perhaps I'm missing something...

It works fine for the obvious use of Wave, which is a multiuser conversation, with nested (and media-rich) responses. As I try to bend Wave to other uses, I'm finding it not so flexible, which might be the client itself, or the Wave system overall. One idea that I'm trying is using Wave as a rich document, using replies as nested blocks under headings, subsections, etc.

One problem I've found is that you cannot reply (as a nested reply) to the most-recent blip; it changes the reply into a "continue this thread" type of blip instead of nested under that specific blip. Additionally, if you want to reply ahead of other replies, you cannot: the "insert reply here" inserts it after all other replies to that blip. I'll admit that, for the sake of a conversational flow, this makes sense -- I shouldn't be able to reply after someone else, yet have it appear before theirs. But is this just a client restriction, or something that just isn't allowed in the Wave protocol? Not being able to insert anywhere takes away a range of potential uses for Wave, which would be too bad.

I'm still waiting for Developer access to Wave, so I can try some Gadget and Robot development. But perhaps until then, I should poke into the protocol a little more to see exactly what I'll be able to do.

Wave language

2009-10-02T08:42:00.001-07:00

Of course, after thinking about a Wave compiler, I started thinking about what language might be interesting to try this with, trying to think about how you would handle code across multiple source files (is a Wave a source file, a Workspace or a Project?), and how difficult different languages would be to implement. But what if, instead, you designed a new language (because you can never have enough), one that was designed to be written within a Wave, designed to run within a Wave, and was Wave aware?

Not having looked into the Wave protocol yet, I don't know how references to different blips inside a Wave work, nor how references to a Wave is done in general. But if blips were functions, or code blocks, contained within other blips that were modules, a Wave compiler for this language would inherently understand the layout of the code within the Wave.

I would expect that a language that lived within a Wave would be a very "web" language, one that used Waves as core data structures, that output HTML, used CSS, and was DOM-aware in the language. In fact, the execution environment might be a Wave itself, which is seeded with the initial code and then the Wave itself is both the execution environment and the input/output environment. It would be a terrific environment for self-modifying code.

It's likely this language wouldn't have a Wave compiler so much as a Wave interpreter, something that read and executed the Wave on the fly instead of actually outputting anything in p-code, byte code, or machine code. This would be, in the Wave way, a robot which was part of the Wave, keeping track of its own "program counter" but letting the Wave environment keep track of data. The types of applications that this language would allow ... well, I'm not sure: it allows for "multiplayer" (not meaning to necessarily imply a game) applications where the users can "catch up" to what's happening at any time just by looking at the Wave, since it will present the current state of the application at any time.

Of course, a lot of the ideas that come to mind for collaborative applications -- a calendar, say -- are also doable with a Gadget inside a Wave, and don't require Yet Another Programming Language, nor a robot to help. But ideas like these aren't borne of necessity, they're a technical exercise that, perhaps, get turned into something useful.

Now I wonder if I could turn this into a Master's thesis...

Wave compiler

2009-10-02T08:24:00.000-07:00

While getting ready for work this morning I had Wave on the brain, And while thinking about the revision control idea, and how a robot might act upon the changes near-instantly, that got me thinking of other tools that might act immediately upon changes being made.

What if your code editor edited a Wave instead? Many code editors have the Intellisense idea, where it will help you out with the parameters in the function you just mentioned and automatically close your parentheses, brackets and curly-braces for you -- all features I personally hate. Some people like them, though, and you could have such functionality in a Wave robot, watching your edits as you go and helping out. If you pause after typing

MyFooFunction(

it might guess that you have completely forgotten the parameters for the function, and will attach a reply to that function, having the parameter values supplied underneath the line you're editing. As soon as you close the function, the robot would remove the hint and let you get on with your coding. It could also help out with the closing of the function call or a block of code...

In fact, it could be constantly compiling your code for you, checking for undefined variables, syntax errors, type mismatches...

It would have to be aware of where you are in your code, what you're currently writing; it shouldn't complain about half-written statements, unclosed code blocks, etc., if the user is still working on them, but lines that have been typed previously, finished with a definitive carriage return or semicolon, could be fair game for reporting errors. These errors might be represented as highlighted code using markup (colours, underlining, etc.) or with reply blips attached to the problem instruction, variable or statement. These markups would be removed as soon as the user goes to tend to them.

A full-fledged compilation system might maintain a different blip in the Wave where it dumps all compilation errors, lint warnings, etc., in case the user wants to tend to bugs that the compiler isn't brave enough to report quite yet, unsure if it's being too hasty. Hell, depending on the type of application, the output could, if the code successfully compiles, be placed within the Wave.

And none of this touches on the idea of multiple humans working on the code at the same time.

Revision Control

2009-10-02T08:11:00.001-07:00

One of the first Wave ideas I had, while watching Google I/O presentation on Google Wave was to use it as a revision control system, allowing for reverting through the playback mechanism of Wave, and for simultaneous editing if a Wave client was used as the code editor. Later in the presentation, they mentioned this idea, and I wasn't surprised that I'd be the only person to think of it.

It's still in mind though, because here at work, we have a host management system, written in XML/XSLT, created by me. This concentrated all of the various data associated with hosts (network addresses, hostnames, usernames, etc.) into a single place, instead of across a half-dozen files, in various directories, on various hosts. This system, too, lives under revision control, to ensure those who edit it aren't colliding their changes. Presently, I'm rewriting the system into a Python/YAML system, for reasons of speed, sustainability and readability.

But as Wave is opening up, I picture this system using it, where a single Wave contains all of the data about all of our machines: multiple users can be editing this data at the same time, seeing each others' "presence" in the Wave as we're doing it, and a robot could watch the Wave and crunch the data when it detects that things have changed, immediately.

Of course, I doubt I'll be able to push a Wave solution here at work, at least, not until Wave takes over the world, but it's a nice idea...

What, another one?

2009-10-01T12:30:00.001-07:00

Yes, another blog... I've decided to start playing around with Google Wave, but couldn't decide if I should have a blog JUST about that, or about programming in general, or about things-that-aren't-already-covered-by-other-blogs. So for now, it's in this blog, and will either get its own blog, if I stick with Wave and have lots to say about it, or will just take over this one, if I find I've got nothing else to say.