I started playing the amazing MMORPG computer game, EverQuest (often abbreviated as “EQ”), almost a year after it was released in 1999. What followed was five or more years of pure gaming bliss, consisting of fun friendships and even an authentic sense of [digital] accomplishment. While the game still lives on successfully even as of my writing this post, numerous expansions and changes have altered the game from its originally challenging and people-dependent playing style. Ever since, players have longed for a way to go back to the glory days of EverQuest, and thankfully, Project 1999 provides that exact opportunity!

As quoted from its home page at project1999.org, “Project 1999 is a free to play Emulated EverQuest Server giving players the opportunity to experience Classic EQ Once again, starting with the original 3 continents and a max level of 50 [increased to 60 with the subsequent release of Kunark and Velious], with the look and feel of the old interface and several modifications making game mechanics similar to how the game used to be. Project 1999 is the best and most popular classic EverQuest experience.” Even though it is free to play, the server is supported by player donations and professionally maintained and monitored by developers and in-game GMs. Although it is a progression server, Velious will be its final expansion, at least as of now.

Soon after I learned of the Project 1999 (P99), I acquired the appropriate software (EverQuest Titanium edition client), made the necessary changes and started playing. If you have already legally purchased EverQuest software in the past, the appropriate version is available via download through BitTorrent or similar sources. You can also purchase it from Amazon or eBay. The P99 web site details the steps necessary to get the game working correctly, and a custom EQEmu patcher is available to make the necessary modifications easier. Furthermore, if the pre-Luclin look of the game is just too dated for you, you can download the Luclin enhanced texture versions of all the game zones from the P99 forums.

So far I have loving playing P99 just as much as I did over a decade ago. The quality of this game really shines even against current MMOs. So whether you are a veteran EQ player or have only just learned of it, be sure to give Project 1999 a try and relive EverQuest the way it was meant to be played!

The first file is the server which should run fine on any modern Linux operating system. The client should also be run on Linux, and can connect to the server from any networked computer on the same subnet. I have had some success connecting this client/server to a similar program written in Java, though you may need to play around with the buffer sizes in each.

I also included a few custom commands for the client to execute. The comments in the source should be sufficient to explain what is going on to experienced Python programmers. I know I am terrible for this, but I cannot remember from where I took the original source code before modifying it. Enjoy!

Client.py

import socket
import sys
import time
# Default connection parameters
client_host = "localhost" #Address of server
client_port = int(9020) #Port used by server
time = time.strftime('%l:%M %p %Z on %b %d, %Y') # Client start time
login_time = str(time) #Convert client start time to string
print "Client initiated at: " + login_time
# Override default parameters (optional command line arguments)
if(len(sys.argv) > 1): #One parameter argument provided by client
 client_host = sys.argv[1] #Override host server IP default "localhost" w/ first argument
if(len(sys.argv) > 2): #Two parameter arguments provided by client
 client_port = int(sys.argv[2]) #Override host port number w/ second argument
# Set up client socket connection
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((client_host, client_port))
# Loop indefinitely while client running
while 1:
 server_data = client_socket.recv(2048) #Receive server data into buffer
 client_data = server_data.lower() #Lowercase received data for processing

 # Process received data
 if (client_data == 'adios'):
 client_socket.close() #Close socket connection
 break;
 else:
 print "(SERVER REPLY)",server_data #Feedback from server
 server_data = raw_input("SEND TO SERVER>> ") #Get client input from keyboard
 client_data = server_data.lower() #Lowercase client input

 # Sent commands
 if (client_data != 'adios'):
 client_socket.send(server_data + "\r\n") #Send data to server if not "adios"
 else:
 client_socket.send(server_data + "\r\n")
 client_socket.close #Otherwise close the socket connection
 break;

Server.py

import os
import re
import socket
import sys
import time
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Create socket
server_socket.bind(("", 9020)) #Bind server to this socket
server_socket.listen(4) #Max number of queued connections
# Welcome message
print "TCP chat server now awaiting client connection on port 9020..."
chat_log = [] #Contains chat log
time = time.strftime('%l:%M %p %Z on %b %d, %Y') #Server start time formatted nicely
start_time = str(time) #Convert server start time to string
username = "ChatUser" #Default server username if user does not provide one
# Support ~2^x client connections, where x is the number of process forks
os.fork()
os.fork()
os.fork()
# This variable contains the help documentation for the "help" command
chatHelp = ("The chat server accepts the following commands:\n"
+ "adios Closes the program\n"
+ "connection Shows client connection info (IP, port)\n"
+ "get Returns complete chat log\n"
+ "getrange <#> <#> Get chat log entries from <#> to <#> (starts at 1)\n"
+ "help Lists valid commands\n"
+ "name: <text> Sets your username to <text>\n"
+ "test: <text> Echo data back to you <text>\n"
+ "time Shows time when server was initiated\n"
+ "push: <text> Add <text> to chat log\n"
+ "save Save chat log to file\n")
while 1:
 # Accept connection
 client_socket, address = server_socket.accept()

 # Print connection info from client for server log
 print "Received connection from client at", address
# Used in the connection command function (client request) below
 connection = str(address)
# Send welcome string to client
 client_socket.send("Welcome to Nigel's chat room! You are logged in as ChatUser.\n Type help for a list of valid commands.\n")
# Loop indefinitely while server running
 while 1:
 data = client_socket.recv(2048) #Receive client data into buffer
 process_data = data.lower() #Lowercase received data for processing
 print "Data received from client>>", process_data #Print data received from client for log reference

 # Functions for the received commands (I use the find library to reduce compatibility errors with other languages)
 # ---"adios" command function---
 if (process_data.find("adios") == 0):
 client_socket.close() #Close socket connection
 print "<Ctrl+C to exit.>>"
 break;

 # ---"connection:" command function---
 elif(process_data.find("connection") == 0):
 client_socket.send("Client connection info: " + connection + "\n")
 print "User requested connection information"

 # ---"getrange" command function w/ regular expression filtering (must be BEFORE "get" command function)---
 elif(re.match(r'getrange\s+(\d+)\s+(\d+)',process_data)): # Regex to find correct match with dynamic numbers input
 match = re.match(r'getrange\s+(\d+)\s+(\d+)',process_data)
 getValue = "Chat log from range "+ match.group(1) + " and " + match.group(2) + ":\n" # Grab first and second range number provided by client
 if(len(chat_log) >= int(match.group(1)) and len(chat_log) >= int(match.group(2))): # Check to see if chat log extends to given range
 count = int(match.group(1)) - 1
 while(count < int(match.group(2))):
 getValue += chat_log[count] + "\n"
 count += 1
 else:
 getValue += "<>\n" #No data in range provided by client
 client_socket.send(getValue) #Send results to client
# ---"get" command function---
 elif(process_data.find("get") == 0):
 log = "Chat log: \n"
 for item in chat_log:
 log += item+" \n"
 client_socket.send(log)

 # ---"help:" command function---
 elif(process_data.find("help") == 0):
 client_socket.send(chatHelp + "\n")
 print "User requested help"

 # ---"name:" command function---
 elif(process_data.find("name:") == 0):
 username = data[5:].strip() #Only grab the value client set (not "name:")
 client_socket.send("Username set to: " + data[5:] + "\n")

 # ---"test:" command function---
 elif(process_data.find("test:") == 0):
 client_socket.send(data[5:]+"\n") #Echo last 5 elements to client
 print data

 # ---"time" command function---
 elif(process_data.find("time") == 0):
 client_socket.send("Chat server was started at: " + start_time + "\n")
 print "User requested server start time"

 # ---"save" command function---
 elif(process_data.find("save") == 0):
 print "(Saving chat log to file)"
 client_socket.send("Saving chat log to file..." + "\n")
 filename = "chat.log"
 file = open(filename,"w") #Create file
 for item in chat_log: #Loop through elements in chat_log
 file.write("%s\n" % item) #Write elements one by one on a new line
 file.close() #Close/write file

 # ---"push" command function---
 elif(process_data.find("push:") == 0):
 print "(Pushing data to chat log)"
 if(username != ""):
 chat_log.append(username + ": " + data[5:].strip()) #Save actual chat text to log (not "push:")
 else:
 chat_log.append(data[5:].strip())
 client_socket.send("OK\n")
 else:
 print "<<Unknown Data Received>>",data #Server log
 try:
 client_socket.send("Unrecognized command: " + data + "") #Advise client of invalid command
 except socket.error, e:
 print "<<Ctrl+C to exit>>" #Server log
 break;

Unless you’re a computer person familiar with file systems it might not make a whole lot of sense or seem funny at all, but at the very least Emperor Steve is pretty hilarious.

Click on the “Vimeo” button on the bottom right of the player to view a larger version of the video. Otherwise click play and enjoy!

On October 11th my mobile application entitled BYU Mobile Student (v1.0) was certified and released to the Microsoft Zune Marketplace for use with Windows Phone 7, free of charge. You can view the latest version in the marketplace here. Although I imagine that the market for university students at BYU Provo who use a Windows Phone is limited, this app was nonetheless a rewarding exercise in Visual Studio development using C# and Silverlight. Currently the app boasts the following features:

• Academic Calendar
• Campus Map
• Location Map (new w/ version 1.1 release)
• Testing Center Line Conditions
• Twitter
• Useful Links

Although I think the WP7 interface is pretty smooth and that the Microsoft App Hub provides some useful tools/support to developers, some of the features in this app were much more difficult to implement than they should have been.

For example, I needed the high-resolution campus map image to be pannable/zoomable within a scrolling control, but due to the lack of availability of built-in elements to handle this (and hours wasted searching for a real solution), I ended up sticking it in a custom web viewer container which luckily had those controls built-in. The downside is that the image has to be downloaded from a remote source instead of local phone storage, causing a slight slowdown during the initial app load time and unwanted dependency on the data connection. With a newer build of the current version 1.1, I was able – with the help of a knowledgeable friend – to finally get the web container to display the image as local instead of remote content.

Another hiccup is that for Microsoft certification, every app candidate must explicitly handle “tombstoning” or app resumption. The known method for saving the current page state before pausing the app and eventually restoring it, however, is buggy in the original version of the Windows Phone 7 OS and crashes the app. I had to work around this by simply not saving the page state but implementing the default behavior anyway in a roundabout way just to satisfy a requirement. With version 1.1 running Mango though the issue has finally been fixed and overall phone performance is much better. Still, a little refinement to the developer tools will take WP7 a long way toward competitiveness against Apple’s iOS.

The WP7 SDK in conjunction with Silverlight is certainly a viable app framework that provides a wealth of functionality with relatively little overhead. Overall I highly recommend it to potential and current Visual Studio developers.

The fact that the original Microsoft XBOX can be modified into a potent media center computer has been well known by many for years; however, a number of the once useful guides scattered across the Web have become cryptic and outdated. Here I will attempt to provide a fully updated guide for those who still wish to transform their outdated gaming system into a piece of hardware worthy of the entertainment center. This guide will review the procedures needed to modify the console via a popular software exploit as opposed to using a mod chip. The steps listed below come from various sources on the net as well as my own personal experience (see the sources section).

A softmod results in the original operating system or “dashboard” being replaced with a homebrew one like UnleashX or EvolutionX, which was the first modified dashboard available. Some of them are rather limited in functionality by themselves, but can be greatly enhanced by launching applications from them like XBMC (which can also be used as a native dashboard). XBMC is a media center program first developed for the original XBOX, but has since been designed to run on numerous computer devices. The official version of XBMC in its current form no longer supports the XBOX, but others have continued its legacy by developing a modern version of the program designed specifically for the console, now known as XBMC4XBOX.

Features:

What can a modified XBOX do exactly? The original dashboard is limited to managing game saves on the hard drive/external memory cards, playing audio CDs, launching commercial game discs and playing region-specific DVDs with a proprietary playback kit. With a modded XBOX running applications like XBMC, on the other hand, you can do the following tasks (listed in no particular order):

• Copy DVDs and games directly to the internal hard drive or networked computer
• Play games/videos from the internal hard drive or videos from a networked computer
• Region-free DVD player (even without the playback kit)
• Play classic video game emulators
• Watch videos streamed from YouTube, Apple Movie Trailers and dozens of other sources
• Run custom Python scripts and Linux bootloaders
• Check the weather and view RSS feeds
• Transfer files to/from the XBOX via FTP or Telnet
• Upgrade the internal hard drive to gain extra space for your files
• …and more!

The only downside to modding the system used to be that XBOX Live gameplay was no longer possible. Microsoft has since discontinued online support for the console though, so mod away! Follow this guide at your own risk. I am not responsible for any errors or problems that arise.

Materials:

• Original XBOX console + controller, A/V & power cables
• An official copy of Splinter Cell (*any version of the original game but not the sequels)
  
• Action Replay kit for original XBOX (somewhat difficult to find) -OR- memory card preloaded with the necessary softmod files (check eBay)
• Router w/ available port + Ethernet cable
• An FTP client like FileZilla

*Specific versions of 007: Agent Under Fire and Mech Assault games also work, but are not covered in this guide.

Procedures:

1. Download and extract the softmod files

I cannot provide a direct download link to the softmod here because a certain company is still surprisingly vigilant about quashing usage of the files. For now, you’ll have to Google around or check out the article linked in my references below to obtain the download. If you have a pre-prepared memory card with the necessary softmod files (obtained through eBay or other means), ignore this download and continue on to step 2. Otherwise, the ZIP archive contains 3 important files:

• SID.Splinter.Cell.v2.0.XBOX-HQ.zip
• SID.Splinter.Cell.v2.0.NTSC.XBOX-HQ.zip
• SID.Splinter.Cell.v2.0.PAL.XBOX-HQ.zip

Extract the ZIP archive to a convenient location. The first file inside of it will later be used as the source code to install the new dashboard (using the Splinter Cell game). The NTSC and PAL files contain a special save profile necessary to launch the installation of the new dashboard. Your XBOX’s video region will determine which of the two region files you must use (generally speaking, North America and some of South America use NTSC and Europe uses PAL).

2. Download XBMC4XBOX (patience… the link may take awhile to respond)

The XBMCSVN site has the latest builds of XBMC4XBOX available for download, the most recent of which is version “3.0.1 Stable” provided in the link above. Don’t be confused by older guides that refer to the original T3CH version of XBMC from 2006. Extract the ZIP archive to a convenient location on your computer so that the appropriate files inside of it can be sent to the XBOX later on.

3. Copy the softmod files onto a memory card via Action Replay (section a) -OR- Use a pre-prepared memory card (section b)

a. If you have an Action Replay kit for XBOX, install the included software CD onto your Windows PC (compatibility mode or other tricks may be necessary for versions of Windows newer than XP). Plug the included USB cable and 8MB memory card into your PC. Drag and drop the SID.Splinter.Cell.v2.0.Xbox-HQ.zip and SID.Splinter.Cell.v2.0.NTSC.Xbox-HQ.zip files from the extracted ZIP archive downloaded in step 1 into the “PC Database” column of the Action Replay software (or the PAL version where needed). This process will create a “LINUX_Profile” saved game in the Splinter Cell folder and a separate “Linux Installer” folder. Next, drag and drop the “Linux Installer” folder into the software’s “Memory Card” column.

b. If you have a pre-prepared memory card mentioned in step 1 which contains all of the necessary (and compatible) softmod files, you are set. Continue to step 4.

4. Transfer the Linux installer files onto the XBOX hard drive.

Remove the memory card from the Action Replay kit (or your pre-prepared memory card) and plug it into an XBOX controller connected to the system. Verify the disc tray is empty and start up the XBOX so that the factory dashboard loads. Navigate to the memory area and continue down the file hierarchy to the active controller’s memory card. When you see the “Linux installer” (or similar) saved game, hit the right button-pad once to select the game, then select the “Copy” function from the menu to copy it to the system’s hard drive. With the pre-prepared memory card, copy both files to the system and continue to step 5.

Shut down the XBOX and go back to the Action Replay program on your computer. Repeat the same process with the “LINUX_Profile” file in the Splinter Cell folder of the Action Replay program. Copy it to the memory card (you’ll have to delete the Linux Installer from it first because the memory card capacity is too small to accommodate both folders) then plug the card into the controller, boot up the system and copy the saved game to the XBOX hard drive. Turn off the XBOX and continue to step 5.

5. Install the dashboard

Once the files are on the system hard drive, insert and run the Splinter Cell game. In your game save profiles you will see a new entry named “Linux” or something similar. Go into it and select “Check points.” Shortly thereafter you will see an install screen for the new modified dashboard. Before installing the actual modified dashboard, be sure to run backups of the original Microsoft dashboard and/or your EEPROM. When all of this is complete, select the option to install the softmod to the XBOX. At some point you will be given a choice to install either EvolutionX or UnleashX dashboard. I personally recommend UnleashX, but either will serve you well enough. If the dashboard offers more than one patch version, read help notes on the screen to decide which is best for your needs.

6. Configure the dashboard + FTP client & Install XBMC

Woot! The new modified dashboard has some cool features on its own, but the real power comes with XBMC. Plug the XBOX into a router via Ethernet cable. Go into the dashboard network settings and verify that the system is set to DHCP mode (this will cause the router to automatically assign it a LAN IP address) and that FTP is enabled. The settings on your network may vary. Next, download and install an FTP client like FileZilla on your computer. This will allow you to transfer files to and from the XBOX. In the FTP client, set the host address in the connection fields to the IP listed on the modified XBOX dashboard. The username and password are “xbox” by default on most modified dashboards. Leave the port field blank or type in 21 if necessary.

When a successful connection has been made, you will see the XBOX’s files displayed in a file tree. Navigate into the /E/Apps folder. Copy the entire folder named “xbmc” within the unzipped file folder from step 2 into the XBOX Apps folder. Reset the XBOX and navigate to the Apps menu on the modified dashboard. Select XBMC to launch it. All done! Now you can configure everything to your liking, including setting up network shares and viewing local/streamed multimedia content! The configuration of XBMC can be extensive, so I recommend checking out the XBMC4XBOX Wiki or other sources for help and recommendations.

All done – happy entertaining!

References:

Although much of this guide comes from my own experience, I could not have done it without this Lifehacker article written by Gina Trapini in 2007.