Detailed Proposal

Since GSOC starts tomorrow, here is the detailed description of what I’ll be working on:

TP04 Support for tpclient-pywx

by Greywhind


This project’s goal will be to implement full tp04 support in tpclient-pywx, so that it can take as much advantage as possible of tp04’s new features. This will involve updating the starmap to allow it to work with dynamically specified objects and with objects that have multiple coordinates or that point to media. It will also involve rewriting the orders window to allow multiple order queues, and it may involve changes to libtpclient-py to finish the support for tp04 in the protocol. The latter may include dealing with protocol specifications for the metaserver, frame filters, and version checking for frames

  • This project will not implement research support, as research has not been fully specified.


Main goals, in order of importance:

  1. Merge in changes since the tp04 branch, such as single player (tpclient-pywx + libtpclient-py + libtpproto-py)
  2. Starmap fixes to show new dynamic objects (tpclient-pywx)
  3. Multiple coordinates should be dealt with and displayed properly (tpclient-pywx)
  4. Easy viewing of new dynamic object properties (tpclient-pywx)
  5. Media support in the client (tpclient-pywx)
  6. Order panel reworking for multiple order queues (tpclient-pywx)
  7. Support for “aged” properties being shown differently (tpclient-pywx)
  8. Filter support in protocol, if not already implemented? (libtpproto-py)
  9. Frame version checking, if necessary. (libtpproto-py, or libtpclient-py?)

The most important goals are the starmap displaying dynamic objects and the order queue allowing multiple queues, as these are the biggest features of the new protocol and they currently prevent the client from acting appropriately when connected to a server running tp04. Currently, the starmap does not display objects correctly in tp04, and there are many improvements that can be made in this area, such as displaying media related to an object. The order queue is the primary means of interacting with the game, and it must also therefore be kept up to date.


1. There have been changes to the code since the tp04 branch was split off from the rest of the client work, and these need to be merged in so that the new tp04 support is coupled with the nice new single player features, for instance. This may take some time and some manual changes.

2 + 3. Dynamic objects can have multiple coordinates, and they can have types that don’t conform to the standard “star, planet, fleet” set. These must be displayed properly on the starmap, and the media they can now point to should be represented if possible.

4. There are various new properties that dynamic objects can have. These should be displayed in a clean and comprehensible format in the properties panel.

5. See 1+2.

6. There are changes to orders in tp04 – there can be multiple order queues. This will necessitate a rewriting of the orders panel. Its features will be expanded to handle the changes.

7. ‘Aged’ properties are those that are no longer visible to the client, and are therefore out of date. These should be represented visually.

8. The protocol now allows filters to be defined, such as encryption. This is an important new addition to the protocol, and it should be dealt with in libtpclient-py, if it is not already.

9. Frames can have versions in tp04, and the client can use this to determine whether the frame is supported. This will need to be used to make sure the client version is correct, if it’s not already checked.



  • June 1st: Changes from other branches will be merged back into tp04.
  • June 8th: The starmap will display objects with multiple coordinates.
  • June 15th: The starmap will have support for display of a single image related to an object.
  • June 22nd: Media support will be updated, and more media (possibly of different types) will be supported.
  • June 29th: Dynamic object properties will be viewable in a meaningful way on the current properties panel.


  • July 6th: The new order panel will be started, and will be able to show and interact with at least one order queue.


By the midterm, the starmap will display the new dynamic objects as well as possible, and the properties of dynamic objects will be viewable. The new order panel will be started, but it will not be fully completed.

  • July 13th: The new order panel will be fully functional, and show and interact with multiple order queues.
  • July 20th: Support for ‘aged’ properties will be implemented instead, and ‘aged’ properties will be marked appropriately in the interface.
  • July 27th: Filter support for the protocol will be added if necessary.


  • August 3rd: Any uncompleted sections will be finished.
  • August 10th: Bugs will be fixed, and polish will be added as possible.
  • August 17th: Bugs and documentation will be finished, as much as possible.

There is one extra week built in, as there may be some extra work necessary on libtpclient-py that is not immediately obvious. It has been some time since libtpclient-py was updated to work with tp04, and there may be some sections that still need work. If this is found to be the case, some of the extra time will be used to make these changes. The extra time may also be used to work on the order panel, which may be difficult to design and build in an extensible manner to work with multiple order queues.

Potential Risks and Difficulties:

The implementation of tp04 may be a fairly difficult task to fully complete and polish in three months. Some specific areas that may cause trouble are:

  • the creation of new wxWidgets windows and panels requires quite a bit of fiddling with XRC and it can take time to create a perfect interface. If a window or panel layout is becoming too time-consuming or difficult, I will attempt to make it workable and useful, and then move on and go back to polish it later.
  • the display of dynamically typed objects will be difficult to design in as scalable and all-encompassing a manner as possible. I will try to support the display of all objects, but if this is not possible, I may need to specify that an object has specific characteristics in order to be displayed, such as a link to an image file.
  • filters may be more complex than expected. I will try to look at the full details ahead of time, and plan accordingly.

Required technologies:

Python will be the primary language used, as tpclient-pywx and libtpproto-py are written in Python. XML will also be used and parsed, as the protocol uses XML. wxWidgets and XRC will be used, as the interface is written in wxWidgets for tpclient-pywx.


~ by greywhind on May 22, 2009.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: