I guess the Terminator warned us this time would be coming. Today I committed some of the new features in Parsek to KDE server. You can find a link to the repo here. Give it a try and let me know if you have any problems. Quickly after starting, you will realize this is still very much a work in progress. I guess I underestimated the complexities of building a game client and have failed to deliver all the originally planned features. I see the work done for GSOC as big step in the evolution of Parsek and it will allow me to continue developing Parsek into a premier Thousand Parsec client. Once the coming soon features described below are ready, I will be uploading the GSOC changes to the Thousand Parsec git repositories as well.

Current Features
Users can now connect to game servers, select games, join, and later disconnect cleanly.
A status manager responds to events from the protocol library.
A corresponding status widget displays connection status, server information, and game information.
A clock displays the time until end of turn (EOT) events.
A logger widget provides debugging and error messages. The logger is a implemented with a filterable model.
Users can view the game universe with the object viewer. The object viewer, tied to an object model, provides basic information about selected objects.

Bugs and Quirks
There remains several unresolved bugs that still need work.
1) The object viewer does not display the last modified time in proper format.
2) The object viewer does not correctly read the object type.
3) The EOT clock could be formatted in hh:mm:ss instead of just seconds.

Undelivered Feature Status
Starmap: The starmap is still a work in progress. The starmap will be tied to the object model. Basic drawing is functioning but still need to implement game object coordinate readings.
Messages: The basic backbone for the message system will be similar to the logger. This will be added later this week. The protocol functionality for messages is not yet implemented, but Parsek will be ready for message support.
Orders: As mentioned during the midterm report, this feature was removed from the project scope. I will start working on this after the object system is fully functioning.

Coming Soon
There are somethings not included in the current build. I will be adding these features over the next few days after a little more testing and proper integration. This includes a more robust object model with support for object parameters including resources. The object viewer interface will also be further improved to provide a better user experience. The object model behind the object viewer will be expanded with abstract type implementation and also work with orders, players, designs, and resources. In addition, a player viewer will added shortly. This will provide a display of the game’s player and later allow the user to send a message or read information about selected players. The chat system will be integrated with the logger and both will allow for filtering and sorting.

The next major feature coming soon is an overhauled main interface. The default dock widget system is ugly and the advantages it provides are minimal. This is a game, not an IDE, so I see little need to provide a fully modifiable window. The new main interface will display the game widgets in an organized and effective manner while working with low resolution displays. The target is to have Parsek function well on 800×600 displays. There will also be a splash window at the start which will allow user to connect to games. The connection manager will also include an account manager. A simple custom button interface will replace the traditional application menu.

Future Visions
Future plans include completion of the message system and the order system. I also plan on configuring Parsek to watch for changes in real time and display updates asynchronously instead of downloading all objects at each EOT. I will spend time working on the protocol library to complete support of some the important features still missing. I will try to complete my failed efforts to get the protocol library functioning on Windows by providing supporting network implementation. After the interface overhaul, I hope to extend Parsek to provide support for 3D graphics.

Screenshots

Parsek’s object tree is now functioning. There is still a lot of work to do to clean it up, make it look nice etc but the overall functionality is now there and works. I’ll be adding a seperate widget that popups when a selection is made in the tree and displays the object’s full information, instead of trying to embed it all in the tree’s columns.

Have a look at the screenshot! The tree hierachy matches tpclient-pywx with the exception that lone objects who’s parent are the galaxy (after they have left a system) are all listed at the bottom, instead of underneath their old parent system.

Yay! So I’ll be adding more features to this as well as hopefully getting the starmap in place (now that I know the information from the data model is loaded correctly) in the next few days. Once all the bugs are fixed in the object tree, I’ll add it to the KDE svn branch.

Parsek’s clock is now functional, cleaned up, and integrated with the program’s status bar. There’s still an odd bug I’m trying to resolve that occurs when I spawn a dialog box which somehow resets the clock when it (the dialog) is dismissed. Strange problem but otherwise, the clock is working fine. It is also accurate when compared to tpclient-wx. The status widget is also now functioning thanks to Lee and some fixes in the protocol library. Parsek can reads the server and game information and displays it in a simple widget. Below is a screenshot of the status and clock functionality. There’s still some issues that need to be fixed.

I’m also configuring the “game” selection widget which will spawn after connecting to a server. This will provide the user with a list of all available games on the server and allow the user to select which one to join. While most servers currently only run a single game “tp”, this will be an important feature for the future when servers are running multiple game instances. I have some ideas beyond the basic pulldown/list menu selection for the game chooser which I will try to elaborate on. The idea is to have an overview of each available game displayed and allow the user to scroll through them in a nice manner, similar to Cover Flow on iTunes/iPhone. For the time being however, it will be a simple dropdown menu! Keep it simple until it works! The account creation features of Parsek are also non-existent at the moment as well. I’ll be adding this shortly. In the mean time, I’m also working on the object display features, as I discussed in my last post. Still more to come there as I’m hoping to have that online ASAP as well.

An updated build has been posted to KDE SVN here. Please try it out. Right now many features are disable and it simply acts as a test of the log, the status widget, and the clock. Try building it and connecting to demo1.thousandparsec.net with guest/guest. Note that you have to actually click the Connect button in the connection dialog – the enter key hasn’t been configured yet!

This post is going to be an overview of the current status of Parsek. Let’s have a look at the objectives of this project.

Full Integration with Protocol Library
Current Status: Testing still required
Expected Completion: July 20th
Deliverable: Synchronized Clock

Integrating the KDE/Qt application with the new protocol library has proven to be difficult. The key part of this task involved integrating the Qt application’s event loop with the protocol library’s EventLoop class. The intended design of Parsek is to provide a fully asynchronous client to users. The combination of Boost libraries, network programming, and the Qt tookit has provided a series of challenges. There are still some problems in Parsek’s EventLoop that need to be fixed. I’m planning on building the protocol library in my application for debugging purposes to see where my application is getting stuck. Parsek’s EventLoop may be failing to handle some callbacks from the protocol. I expect it to still take another week before all these problems preventing proper client/server communication are fixed. The deliverable will be what I call the full function clock. The client’s clock will be synchronized with the server and update in real time. It will also receive EOT events. Parsek will also be able to display general game information from the server.

Starmap
Current Status: Only basic widget in place
Expected Completion: July 31st
Deliverable: Basic display of system

I believe once the issues with the server communication are fixed, the starmap will not take long to complete. Right now, as I cannot properly receive information from the server, it is impossible to test the starmap. I’m thinking of temporary testing the starmap by manually creating objects on the client side. That will be the alternative approach to testing the starmap if I cannot get the client to download the data. Qt will provide a lot of the functionality that will make this task easier to complete.

Message System
Current Status: Model in place, basic widget complete, testing required
Expected Completion: August 7th
Deliverable: Full display of game messages

The message system again needs some more time for testing. I believe it will functional quickly. I am still trying to design the message system to update in real time as messages are received. The plan is have a dynamic message display that can be easily sorted by the user.

Object System
Current Status: Not started
Expected Completion: August 14th
Deliverable: Display of system’s objects through starmap and separate tree-based display and information widget

This will by far be the most complicated task of the project. In fact, I can’t say I’m optimistic about having it complete by the end of the GSOC deadline. However, I am certain significant progress will be made in the Parsek client towards having a full featured object display system. The client will be able to the display the system’s object through the starmap and a separate searchable and filterable tree-based widget. In addition, a seperate widget will display information about selected objects. The widget will be configured for media support and displaying the object’s parameters. Another feature I am hoping to implement is the ability for the user to spawn additional object information widgets which would allow them to compare multiple objects simultaneously. Think of it like tabbed object browsing.

Order System
Current Status: Not started
Expected Completion: After GSOC

I don’t expect this part of the project to be completed before the final deadlines. I still plan on working on Parsek after GSOC is over so I hope to still add the order system. At this point I want to focus on the other tasks as I believe they are more important to Parsek.

General Overview
According to the initial plan, a lot of these tasks should already be complete. Clearly the project is behind the original schedule. Creating the eventloop class was difficult and provied interesting challenges. A lot of time was wasted I predict there are still more issues to work out. Despite the slow pace, I believe there is value in the work being done. Even if I fail to complete other tasks, integrating the Qt application with the protocol library’s eventloop and provide asynchronous real-time updating of game information will prove be valuable for future developers. It will serve as a demonstrable example of integrating the protocol library with a GUI toolkit. I plan to provide significant documentation to help future developers trying to complete similar tasks. I’m still confident that once issues with the client connectivity are resolved, many of the other tasks will be able to be accomplished quickly. Despite a significant setback of not including a working order system by the end of GSOC, the Parsek client should at least provide users the ability to watch games as a spectator. In addition, I believe working on simultaneous Linux+gcc and Windows+MSVC builds will prove to be valuable. This will ensure the code for Parsek and the protocol library is fully portable across both systems and allow future developers on either side of the fence to help out with project. Each system has its advantages when testing as well.

My work on Parsek has been challenging. The most important time spent on the project thus far has been overcoming various learning curves to understanding a complex client/server program. I have spent a lot of time getting familiar with the system so I plan to continue on working on Parsek and Thousand Parsec after GSOC is over. I have ideas for improving Parsek and providing great features like integration with a battleviewer or similar 3D system while remaining quick, responsive, and portable.

Unfortunately I’ve been out of commission for more than a week with a pretty bad flu, which I call H1N.5. It has been an up and down ride. I thought I was on the road to recovery before the weekend and my optimistic thinking came back to bite me in the ass. The good news is I’m finally feeling better and have been for the past couple of days. My appetite is back to normal and I have been trying to get some exercise in along with my usual jujitsu practices. The bad news is that I am behind schedule and now have to haul ass to get back to speed.

I plan on working double time over the next couple weeks to re-allign myself with my objectives. I know this blog hasn’t exactly been maintained and updated regularly but my priorities have been strictly focused on code. I have familiarized myself with the C++ TP protocol library. There is a lot of new functionality that is in place as part of the new protocol standard which simply does not work with the existing code in Parsek. I have begun the process of rewriting the existing code in Parsek and found this to be quite tedious. My plan is to now focus on simply building much of the required functionality from scratch rather than trying to retrofit the Parsek code base. In the next few days I hope to have server connectivity and basic game status management functionality in place. I will hopefully have more updates on my progress by the weekend.

I figured I would take a minute to talk about my experience in Boston last weekend. Qt and the KDE organization brought all the North American GSOC students to Boston for coding sprint. It was quite the mix of fun and work.

The hassle of getting stuck at customs for an hour and half and then missing both my flight and connection left a sour taste in my mouth last Friday. Finally getting to meet my fellow GSOC students and sitting down for some crab cakes quickly remedied that. Shortly after getting settled in, we all headed to check out the new Star Trek movie on IMAX and it was a blast! In between I got to familiarize myself with a lot of the other interesting GSOC projects going on this year. Pretty much every major component of KDE was represented in Boston.

MIT! We were hacking in this same building!

Saturday and Sunday were almost non-stop hacking sessions. The Kendall Hotel that we were put up in was literally across the street from MIT so naturally MIT housed us for our coding marathons. Of course, when I say non-stop hacking sessions, I mean non-stop with the exception of eating pizza, going for coffee, and exploring the MIT campus. Nonetheless, most people were pretty focused on getting things done. With a little help, I was able to configure and setup Qt Creator to work with my project. It is quite a fantastic IDE and will definitely suite the cross-platform development nature of this project. It also makes things easy for me, a Linux command line beginner who was birthed in the Windows environment. What can I say? I’ll take an effective UI over the command line any day! I would have liked to get more work done but at some point in the middle of the day, I somehow managed to completely destroy my OpenSUSE installation. It took me a while to get things back online, but when I finally did, I was able to get some more hacking done and get all my tools setup.

MIT's Stata Center was across the street!

Saturday night dinner at an Indian restaurant followed by ice cream at J.P. Licks was amazing. Sunday wrapped down pretty quick since most people had flights heading back Sunday evening. I decided to stay an extra night, check out the city, and do a little shopping. I also managed to sneak in a trip to Legal Seafood where I pounded back all the shrimp I could handle. If you are a sneaker head and are ever in Boston, you definately need to check out Bodega on Clearway Street. The store has a false front that looks like some old, broken down, corner store. A secret entrance behind a vending machine reveals a super cool boutique with some sweet clothes and sneaker collections. Definately worth checking out! I know I bought more than one pair of shoes there…

Bodega shoe store. There's a hidden store behind the vending machine!

I had a great time in Boston. It was super cool to meet other developers in person and work together. You get some extra benefits from working with other developers in person as well, like realizing Qt is pronounced “cute” rather than “cue-tee”. I stole a couple of pictures of the group from Marcus Hanwell, a KDE developer working on Avogadro, who was there as a mentor. I also want to thank Jeff Mitchell for hosting us, showing us around town, organizing fun activities, and making countless trips to the airport! I hope Qt and KDE continue to do this in future years as it is an amazing way to lure new developers into becoming active members in the community.

The team hacking away. Photo courtesy of Marcus Hanwell.

Fueled purely on sugar and caffeine, the team is still hacking away!

Group shot of the KDE GSOC 2009 crew. Photo courtesy of Marcus Hanwell.

Shout out to all my fellow KDE GSOC students! Wish you all the best. I’ll try to get all their blogs linked up here so you can follow their progress too.

KDE and Qt Software have sponsored all North American Google Summer of Code students to come to Boston for a developer sprint. They have been gracious enough to put up about ten of us in a nice hotel right in Cambridge, across the street from the MIT campus. Right now this post is coming to you straight from Building 4 of MIT! The idea of the meet is to get some introduction and tutorials to using KDE and Qt but for the most part it seems most people are already pretty experienced programming in KDE/Qt.

In the mean time, I’m focusing on my task on updating the current Parsek code base to the latest libtpproto-cpp protocol library. The target date for this task is May 29th. After the weekend, I also plan on finishing the needed content for this blog and launching an objective timeline to follow progress.

My attempted tag on MIT's blackboard.

Stay tuned for links to fellow KDE and TP projects.

Welcome to my blog. I will be using this site to track progress on my Google Summer of Code project for KDE. I am working on a client, called Parsek, for the 4x strategy game platform Thousand Parsec. I will be setting up the site and adding more content over the next few days. In the meantime, for more information, check out the links below.

• Google Summer of Code 2009
• PDF Copy of the Project Proposal
• Thousand Parsec Game
• KDE Development Center

Thanks and come back soon!