I’ve been learning quite a bit about HTML, ASP, PhotoShop, Script# and JavaScript while getting to travel back in time reading some of my old D&D books looking for interesting tables to publish.

Browsing the web looking for other examples has only served to give me confidence that I’m designing something useful, well, at least to me! I have received some validation from friends and family who also enjoy roleplaying games that the site is starting to shape up.

Honestly, while it feels good, I feel it still has a ways to go on the usability front. When I use the site on smaller displays (laptops, etc…), the site feels too big and sparse and I find myself wanting to have the information available in a dense format so I don’t have to do any scrolling.

Also, there are nuance features that I desire, like clearing the rolled list or the ability to mail the results easily to myself or perhaps have the site remember my rolls for me and provide a printable summary page.

Work, work, work!  But, in a fun way.

Enough for now. I have work to do!

I’ve had a couple of weeks off of work and as-is my typical nature, I started looking for other projects to code upon.

I’ve always wanted to write a dice roller that understood dice algebraic notation, but never seemed to find the time.  In particular, this kinf of a project is compelling since it feeds my liking to write small parsers and my love of role-playing games.

Needless to say, after finishing a rough version of the program, I decided to survey the web for a new site name.  Now, let me be clear.  I already have 11 other sites that I run (or really use to), so I’m not entirely sure why I would go off and look for another, but yet, here I was, looking for another site.

Wow! It amazed me just how many names were taken. I knew I wanted a .com address to keep things simple, and I didn’t want to always have to spell out the name and I wanted it to fit into the real of roleplaying. Sounds easy enough, right?  pfffft!

After almost three hours of searching, I finally found one that I was happy with (dungeonz.com). I had tried almost 200 other names prior to that name, and even taking the time to review the ‘suggested sites’, no luck.

Once found, I quickly registered the name.  Easy enough…  time for bed.

When I first started to view the syntax of Lua, it reminded me of a language that was closer to Visual Basic and JavaScript rather than C++ or C#.  The former being high-level, interpreted, non object-oriented and the latter having strong types, polymorphism and low-level constructs such as pointers.

I’m not going to digress into a long list of pros and cons.  That’s really a perspective best suited when there is a very specific goal in mind.  In my case, the goal was just to learn the language.  I might inject a personal comment here or there on items I found cool and items I thought might have been done differently.

First-off, resources:

• Lua Interpreter / Main site : http://www.lua.org
• Lua Community Forums : http://www.lua-users.org
• Lua.Net – Integrating Lua with .Net : http://www.codeproject.com/KB/mcpp/luanetwrapper.aspx

There are many other resources out there if you have a particular project or focus for Lua.  Just use your favorite search engine.

One of the early things I heard about Lua is its performance and interpreter size being great for embedded designs.  These turned out to be true.  The code runs very fast and the disk and memory footprints are minimal compared to other interpreted environments.  This was so much part of the vision for Lua that even the regular-expression-like string capabilities are reduced to the most popular portions to minimize the performance and size of the environment.

Lua is not strongly typed.  Variables are able to change their type and be overridden at anytime.  This is similar to JavaScript.  The most interesting type in Lua is the Table type.  It is a combination of an Array and a Dictionary found in other languages.  Here is a list of the built-in types:

• Boolean – Your basic true / false
• Number – Floating point numbers (similar to JavaScript)
• String – Character Arrays
• Table – Mix of Array and Dictionary
• Function – Code
• Nil – Special (think of undefined in JavaScript)
• Other – This represents extensions to the Lua language through the interpreter environment, often extended in C/C++.

Because Lua is a Reflective language, the developer is able to query the type of a variable by utilizing the type(<variable>) syntax.

While basic Lua does not have support for inheritance, polymorphism, etc… there have been some libraries created to emulate and add this functionality.  This is often done by manipulating a namespace table to override functions, yet still call a base implementation.

Namespaces can be implemented through a table and a little bit of Lua syntax sugar.  This creates a set of functions and properties that are scoped and can be instantiated to provide what looks to be class support in the code.  Note: This made me feel more comfortable with the Language coming from an object-oriented background.

Packages are a Lua concept to break a program up into modules and load those packages via a “dofile(<package name>)” function.  Package dependency can be specified via a “require <package name>” syntax often found near the top of a file.

One concept that took me a bit to grasp was that variables created are by default global in scope.  Only by prefixing variable declaration with the local keyword will the scope and lifetime of the object be limited.  Keeping this in mind is important if you are writing a large application or a library of functionality.

If you would like a more comprehensive description of the language, I encourage you to read the Wikipedia article (http://en.wikipedia.org/wiki/Lua_programming_language) or visit the Lua site, download the interpreter environment and play with it!

A virtual world has many options when it comes to handling the death of a character.

• No Penalty
• Repair Costs
• Vitae Penalty
• XP Penalty
• Loss of Items
• Permanent Character Death
• No Death

Some games do not need the concept of death of a character.  The virtual world may be more socially structured and avoid combat or experiences that could lead to character death.  Such worlds solve the death problem by never introducing the circumstances by which a character can die. 

Another world may change the meaning of death to another term (morale comes to mind) so that characters automatically flee when their morale is gone.  In the spirit of this discussion, that would just be a story-telling spin on death and the players will still view it as death (or simply a loss).

By having the penalty for death be minimal, the environment encourages the players to throw caution to the wind and try things that would otherwise be impossible to near impossible.  If not carefully checked, players may also utilize this circumstance to leverage death for other game benefits (teleportation comes to mind).

With a high penalty for death in a game, players are discouraged in taking chances.  Also, there is a greater sense of loss when the character death does occur.  This can lead to players leaving the game after a perceived devastating loss.

Many of today’s popular titles utilize a minimal cost approach.  The idea being to avoid adding a game mechanic that induces frustration for the player and possibly leads to them leaving the game.  This can be seen at a deeper level as characters continue to become more overpowered compared to their non-player counterparts in the game.  This behavior has left many more hard-core players with comments like “Everyone can reach the highest level now.”

For the game designer, the choice between normalizing the game so that more players enjoy the experience versus creating a world where only great players can reach the highest levels is one that often leads to the former.  That said, the indie game designer may opt for a higher penalty to provide a higher-valued experience for their limited player base.  Especially, if the world is meant to represent something historically authentic.

Where will I go with this?  Unknown at this time, although I lean more towards the lower penalty as I cannot immediately justify a valid reason to be more severe on the penalty of death.  That said, as the world design progresses, I will have to address this question.

For the technical aspects, I have been a software developer for 30 years. I have shipped over 25 products in those years covering a wide gamut of specialties. I have had to work with low memory, low bandwidth machines and machines that really had no limitations as far as the software I was writing could push them. For me, software design and development is a series of constraint problems.  This is a deep calling for me and one that I am fortunate to love and get well paid.

For world design aspects, I have significant experience being a player in such worlds, both in pen-and-paper games and single and multiplayer computer games. I have been a world designer for my own pen-and-paper games a couple of times during those years. I’ve met both players and game masters alike that are masters of the craft, and others for whom the game should never be played again.

Thus, when it comes to creating a new world for an online game, my thoughts immediately move towards adapting a pen-and-paper role-playing game. These games have been through extensive play testing, and in some cases, millions of people play them.  There are plentiful resources both in book form and in online databases.  Perfect!

Well, not quite.  One of the key components that works for a pen-and-paper game is that the rules are interpreted by a game master and that game master can, at any moment, apply intuition, cunning or humanity to any given situation and make it work for the players.  This can manifest in making an encounter a little easier if it looks like the players might die, to customizing the treasure as to reward the player of the hour.

The ability to inject creativity in real time is what cannot be so easily replicated by ones and zeros and a stream of computer code. This is part of the soul of a world designed by a person, run by a person and played by people that person is often familiar with.

In this day and age where MMORPG’s are common place with millions and millions of players (more than pen-and-paper games) are experiencing virtual worlds, it turns out that the most successful ones are those not generated from pen-and-paper games, or even those generated from canon based on books or movies, but those game that were specifically designed originally for the computer environment.

In parallel to the initial code development, I will start the world development. There are plenty of resources out there. I will tag this differently as to permit myself and others the ability to track the progress of the World Design.

Getting Started seemed easy enough.  Just visit the Getting Started section on http://silverlight.net

Here’s a quick rundown of the required steps:

• Make sure Visual Studio 2008 is updated to SP1
• Install the Silverlight Tools for Visual Studio 2008 SP1
• Download the Silverlight Toolkit

Easy enough.  Well, not exactly.  It took a bit to download and update Visual Studio.  Everything else was pretty quick.

Moving on, I started by doing a bit of research on the web with utilizing sockets in Silverlight 2.  It’s important to remember that Silverlight 2 doesn’t contain the full .Net framework and that for security reasons, many API’s are limited or not available.

Sockets proved to be no different.  While the API’s are basically the same, I couldn’t get my sample application to connect to my localhost.  I kept getting an accessed denied error.  After spending many more hours on the web doing some research, it turns out that there are a few restrictions and a special service one must be running to get this to work correctly.

I’ll save you the gory details.  Those can be found on MSDN

http://msdn.microsoft.com/en-us/library/cc645032(VS.95).aspx

Quick summary:

A service must be listening on port 943 that can serve up a policy file similar to the following:

<?xml version="1.0" encoding ="utf-8"?>
<access-policy>
  <cross-domain-access>
    <policy>
      <allow-from>
        <domain uri="*" />
      </allow-from>
      <grant-to>
        <socket-resource port="4529-4534" protocol="tcp" />
      </grant-to>
    </policy>
  </cross-domain-access>
</access-policy>

The Silverlight 2 application is only allowed to open a connection back to the same server that launched the application.  It will then get the above policy file and use the rules to determine if it has permissions to talk to the server.

Once that hurdle was completed, the application started working like a charm.

For any online game, the ability to communicate is paramount.  It’s a fine balance between access and scalability.  Too many people in a chat system causes the user to perceive most communications as noise, while too few people means that communication cannot be an effective means of solving problems or social interaction.

After some thought, it feels like a chat system basically breaks down into four primary areas:

• System Channels – These are often used by the server to communicate to the client or to all players at once.
• Public Channels – This represents communication without moderation.  Often, these channels are predefined by the game system to help group similar types of communication (i.e. trade, guild, etc…)
• Private Channels – This is often one-on-one communication.  This can manifest as a direct message between players or as private communications between the game and the player (think NPC chatter specific to player)
• Created Channels – These are user-created channels to facilitate communication with friends or people with similar goals.  These can be controlled and moderated and may require passwords to join.  There is often an owner associated with the channel with moderator privileges.

Within those systems, players need a user-interface that provides good control of what they are seeing and how that information should be seen.

• Window control – The ability to direct and control chat windows.  Identifying which channels should show up in which windows and if new private messages should show up in new window instances or in a single window.
• Coloring – The ability to specify the color (or possibly font) of the users choice for text output.  This should be done on a channel level.
• Formatting – Allowing the formatting of text.  This could be limited to only bold, italic, color, font or whatever is appropriate for the environment.
• Address Book – This can take the form of a friends list in some games, but the ability to get access to a list of people, get information or status about them (online vs offline), and initiate communication.
• Linking items – A staple of game systems is the ability to link items (or skills, abilities, etc…) into chat. Open question: Is there an opportunity here to allow users to link to other pieces of the user-interface to act as a sort of social help program?
• Hyperlink support – The option of supporting hyperlinks in chat and launching a browser on interacting with the hyperlink.
• Filtering – At a minimum to have a list of terms or regular-expressions to keep some forms of text from being displayed.  While this may be a form of censorship for some games, for others it may be necessary to prevent some magic phrases from triggering code or for legal or geo-political sensitivity reasons.
• Ignoring – The ability to identify a person and ignore them.
• Reporting – The ability to report a person for their chat for violating the terms-of-service agreement.
• AFK (away from keyboard) – The ability to indicate to others your status and possibly set a message that is displayed when someone talks directly to you.
• Who – The ability to find other people and get information about them before they are on a friends list.
• Anonymous – Preventing others from getting status or other information about you.
• Placeholders – Often used for macros, the ability to specify a generic placeholder for a defined item.  An example might be %N for the name of the target or %L for a location.

I’m sure I will continue to grow this list.  By implementing this structure, I will have the opportunity to explore options with the client and the server and to investigate scalability of the infrastructure and architecture.

LuaMud – The first thing I did was go and purchase the LuaMud.com and LuaMud.net domain names for the project.  I utilize Network Solutions for managing my domain names as they have been around for quite a while.  Some of my domain names are almost 15 years old now and Network Solutions was really the only game in town when I started.

Fortunately, NetSol was having a special and I was able to book both domain names for the price of one.  Word of caution.  Network Solutions has become very commercial and it can be a bit cumbersome to register a domain name and then be asked if you want one of fifteen services.  After skipping all the propaganda, the domain names were registered.

I host my own domains on my server, so now I needed to update my DNS records to point to my server.  This was easily done from the Network Solutions web site.  I then had to configure my server to be ready to receive connections on these two domains, including setting up a dumb default page with a simple “coming soon…” string for the default page.

Hopefully, by tomorrow, the domain name and updated DNS entries will have propagated across the Internet and the site will be active.

Once the site is active, the arduous task of setting up the site structure will be next.  I suspect I’ll want some form of forums, or perhaps a wiki, or maybe I’ll just link to a 3rd party site that hosts those services.  Looks like another blog entry in the works.

I would like to utilize the following technologies:

• .Net Framework, C# preferably, C++ as a fallback for necessary components
• Lua as the scripting language
• Silverlight as the client platform
• Visual Studio 2008 as the development environment

Following is the list of initial resources I’m using to put together the scripting engine:

• www.lua.org – Primary site for all things Lua.  Great starting spot containing links to many libraries and even a live demo that can be run from the browser.
• lua-users.org – Community site containing extensions and discussions (Lua Addons)
• Lua Socket library – Well, I need to get network connectivity somehow.  This seems to be a pretty standard library for doing so.
• LuaForge – Source repository for a lot of Lua projects including the Sockets library
• Generic Game Server v2.0.1 – Great little Lua generic game server.  Looks to be what I want already written along with sources should I need to enhance it.

Well, to my surprise, after downloading the Generic Game server and playing with it for a bit, I was actually able to get a very rudimentary MUD framework in place and it loaded, allowed connections, etc…  It took a little wrangling for me to get the Lua syntax down correctly and to have it work correctly with the software communication interfaces.

Based on this, utilizing Lua is a go!  Now to go get a domain name to host all this great information and the builds, etc…

When I use to code for a MUD, the MUD utilized LPC as its scripting language.  LPC was developed by Lars Pensjö for scripting in LPMuds.  I took some of the original code and specialized it for my own MUD, which was never released.  This was over 10 years ago, but I still have the code, a good base library and a basic understanding of the language still.

Lua is another scripting language known for its speed and its efficient garbage collection.  The other big benefit it has is that World of Warcraft uses Lua for programming its interface and thus has generated quite a few followers in the gaming community that know how to write code in Lua.

All that said, both languages are fairly similar on many levels.  The real power for both of these languages comes from the extensions that are built and specific to their running environment.  Given that 90% of the functionality comes from these extensions, it is not immediately clear which of these languages might be best suited.  Heck, for that matter, one could throw in JavaScript (or ECMAScript for the savvy) as a viable contender.

One of the other advantages that Lua has is documentation.  There have been many websites, articles, blogs and even a book or two written about Lua.  It is also under current development.  The only downside is that I’ve already got a significant amount of LPC code written for my old MUD.  Maybe it’s time to give up and just use the old code as a framework of ideas and start fresh.  The downside to doing so means an additional month or more of coding just to get a basic library of routines built up.

Well, that settles it.  In my opinion, the scorecard comes out in favor of Lua.

Expect to see more articles on how the adoption and learning of Lua is going.  I will post my sources of information and downloads so everyone has a chance to share.  When I finally get to some minimal level of code and framework, I will post that work for others.