Virigoth’s Spiral

What’s New with Spireal:

January 6th

Link to the Forum Post at www.spireal.com

Been a while since I updated on the project.  Mostly due to the fact that my life has been very focused on getting a new job and moving out of EA, which is consuming most of my energy.  Got a couple of things done over holiday break however.

1.  The heap memory manager is all complete and tested.

2. Our file manager now uses proper heap for it’s file allocation.

3. The source code is now up on our google subversion source control at:  http://code.google.com/p/spireal/source/browse/

This means that you can now download current version of the Spireal project at any time.  I’ll be adding installation instructions sometime soon to explain how to rebuild and compile the project.

Next target:

Finish the memory management by adding a memory pool manager used for creating and reusing lots of small objects.  Example: code objects, game items, monsters etc.  Stuff that would normally fragment the crap out of the heaps.

We’ll be using the boost library “pool” class for this.

December 1st

Link to the Forum Post at www.spireal.com

It’s been busy two weeks, but the Thanksgiving break gave me some time to paint some new code for Spireal.  Things that got done:

- We now have an XmlReader and an  XmlWriter which allows the server and client to use XML files to read and store data.  This is VERY cool since xml is extremely powerful for configuration properties, and we will most likely be using it to define various user settings, media data (sounds, dungeon tiles, UI) so that everything is easily moddable on the client and server side.

- We now have a FileManager for the game which handles everything needed to read, and load data from disk into memory or write data from memory into disk.  It also allows us to set a data directory to use, so it will be possible to have a ‘default’ data directory, and ‘mod’ directories. For example the client (Spireal) can look and sound totally different because the user added a mod directory overwridding the UI and sound assets.

- Guari now automaticly keeps track of his build version using a special XML file that gets updated whenever the game is built.  This means that the user AND the game can always keep track of what the version is, and if the given asset is too old or too new for a given version it can be avoided etc..  It also allows you to keep track of how much work I’ve done on screen shots heheh

- I’ve started working on a Memory Manager which will keep track of our heap memory use in the game using various tricks to make sure that it’s never fragmented.  This is primarly important for Gauri since it will be expected to run for as long as it can without any performance hits due to gazillion memory allocations over a long time.

To give you an idea how necessary it is:  After about 3 hours of constant OS based allocations, your program can start using about 30-50% of it’s cpu time allocating memory.  If it runs for long enough doing lots of memory work, it will eventually get turtle slow.  So we write our own memory managers to make sure that we use memory in such way that it never costs us extra.

- Whats up ahead:  Finishing the memory manager and hooking it up into the existing code (such as the File Manager which absolutely needs it).  Then we can start building the Spireal client.

November 19th

Not much actual coding progress done but lots of changes never the less.  We now have an official website established by Matt aka Crypticant (back from the ole’ days of Forsaken Lands) and he’s adding much needed art and creative direction to the project
The site includes a forum as well as a wiki to establish a proper environment in which all the creative work can happen.

On the coding progress side of things, the XML reader is done, and I’m working on the I/O manager to contain all the file access in one place.

November 9th
Well its been a very busy week with lots of stuff done.  First and foremost the screen shot of Gauri running on Linux is up in screen shots area.  Making it happen was actually a surprising amount of work, especially since I’m a clueless newb as far as using Linux goes.  All that aside, updating makefiles and building Guari is now a two command process on both win32 and linux.

Next up is the version system which requires XML read/write support which requires basic I/O management which requires basic Memory/Heap management.  I’ve decided to use Expat library as our XML stream based parser base.  It’s very solid, reliable and has been used aton all over the place I hear.

November 4th
Since I can’t vote I finished all the bakefile script stuff instead.  All the currently used libs and the gauri can now be generated for various GDIs and gnu makefiles with one command.  Going to test it on linux tomorrow night.  Next step is automatic versioning in-code while my mind puts together how the client architecture is going to be setup.

October 22nd

All work is on halt.  My wedding is coming up Nov 1st so no real progress is going to happen until after that date.  A whole pile of non-spireal related stuff to be done for the wedding awaits.

October 21

Got a lot of the bakefile stuff setup and out of the way.  Some work remains to setup the project and some simple scripts to build all the libraries on both platforms with a single command.  The sweat upfront should be worth it later on when both the server and client will be built with a single command/batch file and addition of new files/directories will require minimal work in all 4 projects (server linux, server win32, client linux, client win32).

October 16th

Found my cross-platform build solution: Bakefile.  It’s a program that abstracts out most of the makefile functionality and then creates makefiles specific to various development platforms.  It allows you to write a single bakefile and then generate makefiles for MSVC nmake or Linux make etc.

Very cool since it allows you to build your project in very non-platform specific way after the initial setup.  I’m slowly creating the bakefiles for the project now, the goal is to have one-command compilation of both Spireal and Gauri for both Win32 and Linux.

October 15th

Gauri can now hear and speak!  It can recieve telnet connections and echos all client input to all connected clients (echo server).

The Spireal server now is capable of managing it’s connections and uses its own messaging protocol to send and receive data.  The protocol is for now uncompressed but designed so that we can easily add compression later for messages which are larger.  Everything is set for us to start adding memory management, authentication and command processing.

The next step is to get it compiling under Linux, then add automatic versioning for the builds, and then start on the client so we can leave the world of telnet behind.

October 9th

All the libs are hooked up and the development in windows is a go.  I wrote the simplest possible test server which will become the starting point for the real thing.  For now all it does is echo to the console whatever is sent to it

Since the server is going to carry the world of Spireal on its shoulders I decided to give it a name that fits with the motif of mystical white elephant: Gauri.

October 9th

Update the mock image page with a quick picture of what the client most likely look like using the SFML library.

We’re not going for ASCII stuff anymore because it takes exactly the same amount of work as putting in rough ‘programmer art’ representations.  We’ll need more beautiful stuff later once we figure out how the tiling engine will work and how we’re going to do lighting and animation.

October 8th

Where to start, so much got done.  I installed Ubuntu linux so that I can test-develop Spireal in Unix environment as well as usual win32.

I also dusted off the MSVC and got a wallet size backup drive so keep things safe in case of my HD crashing.  I chewed through the first of the two books on TCP-IP/Client-Server design, most of the stuff was luckly just a recall away.

Started working on the server V0.1.  I also found better libraries to use for both the graphics-client side (SFML) and the socket-server side (Socket C++).   As an additional golden find, I found a really lightweight SQL package that is perfect for game DB development.  I was planning to use some sort of SQL DB for the database side of things from the start so this is really really perfect.

I got the whole project directory setup and mapped out, and version control going through Bazaar, pretty much the only thing left is to actually start coding now

After browsing through the SFML documentation, it’s also become pretty clear that there is literly no trade off between doing a 2d tile engine vs trying to do a Rougelike.  Rougelike is still going to require a 2d tile engine anyway.  So the visual goal for V1.0 client is going to shift a bit away from ASCII tiled rendering into some sort of simple 2d tiles.  Rest of the interface is still going to be majorly text driven to keep it low-key in terms of time, but with design that has images and balance of text+graphics in mind.

Sept 27th
I finished the rough mocks of the adventure screen for V1.0 of the client. Who knows when I finish it, but I wanted to set expectations for myself so that when I start dreaming and inventing new things to do I can look at the mock and come down to earth.

Sept 26th
I’ve added the results of the walling algorithm in the Diagrams section. Looks like there should be no problems with walling a Rougelike random dungeon. I’ve also added couple of sketches of Spireal and Spire city in the Concept Art section to better illustrate the idea.

Also a surprising find: I found a complete version of Wizardry7 as well as an editor allowing me to rip 90% of the sprites used in the game. This is awesome as not only is this game one of my most favorite cRPGs of all time, it also provides me with lots of good starting point art source to use as a genesis of Spireal Client’s tile sets.

Wizardry7 download
Cosmic Forge Editor download

Sept 25th
Begun to shape this blog and started to organize the Spireal side of it.  Posted some pics of what’s possible with Doryen library (ASCII tile + 24bit) and toyed around with some programming to test out an algorithm to give the ASCII graphics a starting point from which to work with in terms of the client.  Posted a screenshot gallery of various projects using Doryen Lib.

Sept 24th
Started toying about with photoshop and notepad to create some rough docs as to what the graphics and the UI could look like.  My head is still a fountainhead of creativity and I got the general theme, goals and rough gameplay set out in my head.  I need to write this down on here to slowly start orginizing it.

Sept 23rd
Started working on research, peeking about the net to see what sort of libraries are available to get an idea how much work this will be.  My goal is to use as much publicly maintained libraries as possible to get to the meat and potatoes of the game with least wasted time possible.

Bought some books (three cheers for 5$ books on amazon) on client-server design to brush up on the architecture.  I want to do this right from ground up so that when inevitable design changes happen it all happens smoothly.