Mason Battleplan

by Bryce Harrington

Okay, y'all know how much I love doing battleplans. Here's one for Mason.

Regarding time between releases, I won't specify any particular schedule, but it would be nice to achieve 2-3 releases before the end of the year.

Review Mason, Debrief Acorn, and Assemble Reading List

This will proceed from now until the end of the month [October]. I covered this at length in the previous email so no need to belabor it. ;-)

Zzorn and Cyanide have made a great start on the reading list and I've been plugging away at the debrief article. Morgenes is starting on organizing a review team, to read over the Mason docs and extract some TODOs, questions, and comments that'll help in later development.

We need to have an all-hands Mason kickoff meeting. I'll try to set something up either next weekend or the weekend after.

Mason Release 0.0.1

I believe it is vital for any game project to get a quickie release out as soon as possible. By soon I mean, a couple weeks. Let's take Acorn (UClient and Cyphesis-C++) and rename it "Mason", and put that out as our first release. If we can get anything new into it, that's gravy. I feel this is important because it will get us geared for building onto Acorn rather than immediately reinventing and starting from scratch. Lets not undertake any updates or fixes that would take more than a day to do, lest we allow it to drag us into endless redevelopment.

MEDIA TEAM: We definitely need to get the media team up and running. The team's objective is to gather a set of HOW-TOs on a variety of relevant media topics. Much of this documentation already exists; for example, browsing through back issues of the Chopping Block will turn up a number of good articles. This should include a listing of Recommended Media Tools - a shortlist of applications that we'll definitely support in terms of file formats and HOW-TOs. (This doesn't mean that other apps won't be allowed, just that these will be encouraged.)

INTEGRATION TEAM: This will be a source-only package, consisting only of Cyphesis-C++ and UClient (and associated libraries, media, and data files.) It should compile without errors, and some stability would be nice.

PLAY TEAM: Ensure that we have a live metaserver, stably installed on one of our core servers (victor, moria, etc.)

RULES TEAM: ---

ENTITY TEAM: ---

Mason Release 0.0.2

Next let's shoot for some simple changes. Let start by creating a new map, more geared for the place Mason will be set in. Let's do try to learn about what aspects of the map system need to work, but let's not even start reinventing anything. We will investigate what music, graphics, and animations we have on hand that are not yet folded in, and add them. Let's create a few new AI routines for the critters in there, such as being able to pick up generic blocks or other shapes and move them around. Nothing fancy.

MEDIA TEAM: We will also encourage people to begin experimenting and learning about adding new media, and ensure that artists understand their requirements. If people create new music or art, we should make an effort to try to include it, but this shouldn't be a major focus. We should also review how we currently distribute media, and encourage people to come up with some mechanisms that avoid some of the issues users have had in the past with media incompatibilities.

RULES TEAM: The team should review and learn how rules work in Cyphesis-C++ and consider how this relates to STAGE RIMs, and lay out a plan for how we are going to go about doing rules implementation. This should include a listing of the rule subsystems that we'll need to create, based on the Mason rulebook. We should have at least one new AI routine added to Cyphesis, so we are confident we understand how this works.

ENTITY TEAM: The main objective will be getting Eidetic working well for editing Archetype definitions. We need to be able to output these into Atlas XML format, and need to have some way (manual is ok) to add them to Cyphesis. We need to learn how to create maps and generate a new Mason-specific map, using existing artwork.

PLAY TEAM: Start setting up Acorn games once a week, using the latest released codebase (not the bleeding edge though.) We are also going to need a non-IRC system for holding meetings (either STAGE or Cyphesis-C++).

INTEGRATION TEAM: This release will again include just Cyphesis-C++ and UClient, and other appropriate files. We should make it a goal to have no warnings and to have it particularly stable.

Another important experiment we should explore is getting other clients like silence-py and Frost to be able to connect with Cyphesis-C++.

Mason Release 0.0.3

For this release, we should shoot for achieving connection compatibility between any client and either STAGE or Cyphesis-C++. We intend to use Cyphesis for the initial rule development, since STAGE still has a ways to go, but if we can tackle any incompatibility issues now, it will avoid getting ourselves into a situation that we won't be able to switch over to stage later. STAGE and Cyphesis do NOT need to support the same feature set; it's only necessary that clients be able to connect to either of them with the exact same communication going on.

MEDIA TEAM: The Media team should now proceed with creation of tiles, 3D models, and other such required items, especially things that can be used for the block-stacking work in the next release. The team should ensure it has a detailed media-required task list, and be able to track who is doing what. They should deliver some preliminary media as they see fit, for inclusion in this release.

RULES TEAM: The rules team should have a list of tasks they wish to undertake in order to get the mason rules implemented in Cyphesis-C++. They should deliver some preliminary routines as they see fit, for inclusion in this release.

ENTITY TEAM: The entity team must produce an archetype hierarchy chart for Mason for this release. As well, a set of preliminary entities should be generated and included in this release.

INTEGRATION TEAM: Put as many clients into the package as possible, that can all work together, as well as a stable release of both STAGE and Cyphesis-C++. We should expect some instability and compilation issues, since we're adding in so much new code. This will also be a source-only release.

PLAY TEAM: Weekly game sessions should continue, incorporating and testing out new media, rules, or entities as they become available. The team should have a set of game testing machines organized, and registered as appropriate with the infra team.

Mason Release 0.0.4

The focus for this release is going to be block stacking. We need to make it very easy to pick up blocks and move them and drop them onto other blocks. This is easier said than done, and is going to involve a lot of UI enhancements, and probably some attention to working out lag issues in the network connection.

Block stacking is a simple form of item attachment, so we need to approach this as a prototype of a more advanced item connection system to come.

MEDIA TEAM: Proceed with creation and delivery of items from the media list. Especially focus on creation of new kinds of graphics for buildings, and animations of creatures assembling buildings.

RULES TEAM: Generate rules for block stacking and implement them in Cyphesis and all supported clients. By this point we should have some simple container system also available. We need to be able to put items into a bag (unsorted). The more different kinds of containers we can implement for this release, the better.

ENTITY TEAM: Support for creation of container-type archetypes should be added. Recipe system support should be prototyped.

INTEGRATION TEAM: We also need to start experimenting with hooking Cyphesis to STAGE. We need Cyphesis to be able to manipulate whatever "thingees" are in STAGE, as well as being able to use STAGE as a "gateway" to Cyphesis - STAGE needs to at the least be able to transfer information about player activities into cyphesis, and back. STAGE doesn't need to actually do any translation or processing, but it does need to be "in the loop."

PLAY TEAM: A "building race" should be set up, where individuals or teams compete at creating some structure, such as a pyramid. An article should be written describing how this went, listing technical issues encountered and high points. We want to start figuring out where the fun parts of the system are, so we can maximize those aspects in later releases.

Mason Release 0.0.5

The objectives for this release are to put out binary packages and to review our status and determine what to do for steps 0.0.6-0.1.0.

INTEGRATION: Put out stable source and binary packages for stage, cyphesis, and at least one client. Our media packages need to be very solid and reliable, and easy to install.

Subsequent Mason Releases

Some objectives for these releases: