Google Summer of Code 2007

Last updated: 16 March 2007

Thousand Parsec is one of the mentoring organisations for Google Summer of Code 2007. This is a great chance for all students to work on a cool open source game project during the summer of 2007, have fun and earn some money during the process.

This page highlights ideas and suggestions for student proposals for 2007.

Contents

Students

If you find an idea listed below that you like or have your own idea for a Thousand Parsec open source project, we encourage you to read up about the Getting Started Page, ask questions, and then include the following in your proposal:

  1. detailed description / design document
  2. an approximate schedule (timeline)
  3. brief description of past projects (including open source) that you've participated in
  4. brief resume/bio/contact information

Writing Proposals

The following links detail successful general ways to write a Summer of Code Proposal:

Please read Google's Summer of Code Student FAQ and advice from past participants as you create your proposal.

Feel free to submit multiple proposals.

Good luck!

Selection Criteria

The following gives some indication of some of the things we are looking for. There will probably be some subjective elements to it, but it's hoped that by trying to quantify the decision process, it'll help people understand why their application was or was not accepted.

  • Proposal is longer than a few sentences. We need some meat in the proposal in order to even consider it.
  • Proposer has contacted us prior to the submission. This demonstrates a definite interest in Thousand Parsec and proves an ability to communicate with us.
  • Proposer knows the appropriate programming language(s).
  • Proposer shows evidence of being able to create software. Our goal is to help programmers become good at Open Source, not to teach non-programmers how to program. However, we are willing to help people develop their programming skills.
  • Proposal is well written. While we don't expect perfect English, we do expect that the proposer took time to spell check, proofread it, organize it logically, and use comprehendable grammar.
  • Proposal demonstrates understanding of subject matter. We expect the proposer to do some research, ask questions, and gain some understanding of the project they're proposing. This gives us confidence that they'll be able to complete the project successfully.
  • Proposal shows creativity. We like to see someone thinking outside the box, including proposing ideas for projects we hadn't listed.
  • Proposal is the only submission for the given task. Many proposals focus on the same few tasks, so if you're the only person proposing to do a given project, that weighs in your favor.
  • Proposal shows implementation planning. If the author has broken the work out into a task list, it shows that they know what they'll be doing.
  • Proposal scope is realistic. 2 months goes fast. Proposals that are promising too much are unlikely to be completed in a timely fashion.

The following are conditions that result in automatic rejection:

  • Reject: Group project proposed. Google has specified that groups MAY NOT participate. Individuals only.
  • Reject: Proposer is not a student. Requirement of the program.

Questions

  1. Read up the developer section /tp/dev/index.php
  2. Join the mailing lists or web forums (they are connected so you don't need to join both) and ask questions
  3. Join the Thousand Parsec chat channel, #tp, on irc.freenode.net.

Ideas

Below are some of the ideas and suggestion for students who are interested in joining Thousand Parsec project. The list is not definitive and any student is more than welcome to come up with their own idea to work on. Initiative is a very good skill.

The list is not definitive and any student is more than welcome to come up with their own idea to work on. Initiative is a skill which will rate highly when selecting projects. Feel free to come up with your own projects.

For additional ideas we encourage students to look at Thousand Parsec TODO list.

Project Table of Contents

  • Develop a new client
    • Web based Client
    • Develop a 3D Client (or improve tpclient-pyogre)
    • Develop a MIDP Client for Mobile Phones

  • Improve tpserver-cpp
    • Write a PostgreSQL persistence module for tpserver-cpp
    • Write a SQLlite persistence module for tpserver-cpp

  • Create tools
    • Create a "Ruleset" development Environment
    • Create a Race Designer
    • Improve the metaserver - make it standalone

  • Python Stuff
    • Add testing to libtpproto-py
    • Improve wxWidget's pyAUI

  • Improve the protocol
    • Write a protocol compliance test suite
    • Design and Implement a Research Framework

  • Implement a new Ruleset
    • Implement MTSec prototype ruleset
    • Implement "Reach for the Stars!" Clone
    • Implement "Diplomancy... In Space" Clone

Create a new Client

Thousand Parsec is designed to allow many different clients to connect to the same server and still fully participate. Currently the main client is written in Python. There is also a C++ client for KDE being developed.

We want you to write a new client for Thousand Parsec. This client will service people who are not in a situation to use tpclient-pywx.

These tasks are a reasonable amount of work, depending on which language you choose you may need to improve (or implement from scratch) a protocol library. You will need to be a reasonable coder before you start any of these projects if you hope to succeed.

Web based client

A web based client enables players to join Thousand Parsec games easily from any computer with a web browser and internet connection. This makes web based client the fastest and easiest way to start playing the game.

Any language could be used for the client. Some suggestions are PHP, Python or Ruby. It might be a good idea to use AJAX or something similar.

It is expected that you would produce a client which has the following functionality,

  • Support for displaying the Starmap
  • Support for displaying all information about objects
  • Support for issuing orders
  • Support for creating designs

More Information

libtpproto-php, libtpproto-rb, libtpproto-py

Required Skills

Strong Web development skill.

Develop a 3D Client (or improve tpclient-pyogre)

A cool 3d client for Thousand Parsec is needed. A pyOgre client was started but is in need of quite a bit of love. You could choose to use that as a base or start a new client from scratch.

It is expected that you would produce a client which has the following functionality,

  • Support for displaying the Starmap
  • Support for displaying all information about objects
  • Support for issuing orders
  • Support for creating designs

More Information

pyOgre

Required Skills

Some 3D development skills

Improve tpserver-cpp

tpserver-cpp is one of the main servers in Thousand Parsec. These project ideas deal with improving it in various ways.

You will need some C++ skills before you start any of these projects (but not as much as if you where implementing a ruleset for this server).

Write a PostgreSQL persistence module for tpserver-cpp

Tpserver-cpp (C++ Thousand Parsec server) has an abstract persistence interface that allows different methods of saving the game data. Currently, only a basic MySQL module has been written.

The interface it fairly straight forward, but there is likely to be changes to the interface as the new game features are created and the internal architecture changes.

More Information

PostgresSQL
SF Todo Tracker Item.

Required Skills

SQL (preferably PostgreSQL and or MySQL) experience, C++ experience

Write a SQLlite persistence module for tpserver-cpp

Tpserver-cpp (C++ Thousand Parsec server) has an abstract persistence interface that allows different methods of saving the game data. Currently, only a basic MySQL module has been written.

The interface it fairly straight forward, but there is likely to be changes to the interface as the new game features are created and the internal architecture changes.

More Information

SQLlite
SF Todo Tracker Item.

Required Skills

SQL (preferably SQLlite or MySQL) experience, C++ experience

Create tools

These projects are about improving or creating standalone tools for Thousand Parsec. They are the mostly self contain projects, however it is still expected that you be involved with the rest of the project.

Some of these projects might require you to extend the Thousand Parsec protocol or specify out new features. These will need to be public discussed on the mailing lists.

Create a "Ruleset" development Environment

Scheme is quite a hard language to write. tpcl the language which is used for communicating between server and client the details about Designs, components and properties is based on Scheme.

Your job is to create an IDE which makes it easy to create new components and properties (and develop the scheme code to go with it).

More Information

[1586115] - Create a component editor.
Thousand Parsec Component Language

Required Skills

Scheme or Lisp programming skills a good advantage but not required. Experience with a GUI toolkit (GTK, Qt, wxWindows) would also be a bonus.

Implement a Race Designer

Meet strange and interesting races... and kill them. One of the core tenants of the modern 4X game. Race design for Stars! is an art form, with few major race strategies (HP, HG, -F...), and dozens of minor variations. Other games feature fixed races - do you play the strange robotic machines, or the orange giant insects of Epsilon Persei III.

The goal for this project is to design and implement a protocol for player races. Protocol and server support are a necessity, as is a (portable) client that can create races in some way. Race files will need to be saved and distributed.. Take into account both fixed races (ala Master of Orion) or races built using another ruleset (ala Stars!). Also you will need to have at least one implementation of a game that uses the races in some way - easiest is Minisec, but if others are working on another project building a ruleset, you may work with them. Race files need to be verified in some manner on the server, so take into account how to do this easily.

More Information

Required Skills

Improve the metaserver - make it standalone

The metaserver was written in about 5 hours. It works but requires a lot of work before it's a "good" piece of software. It could also be rewritten in another language.

Some features would include:

  • Implementing the full specification found in the discussion document
  • Make it portable across databases
  • Add RSS output support
  • Produce statistics and some type of graphing
  • "Back Connect" support for verification of details
  • Some type of "match making" support

More Information

[1652210] - Add long term stats to Metaserver
[1652205] - Add match making service to the Metaserver.
[1652204] - Add RSS Feeds to the Metaserver.
[1652209] - Clean up Metaserver code.

Required Skills

Some PHP skills (or other Web development skills).

Improve the protocol

These projects are about improving a core part of Thousand Parsec. They may require a smaller amount of code then other projects, but the code will have to be of a much higher quality.

Any changes to the core protocol will need to be vetted by other Thousand Parsec members and approved. This means that these projects may be slower to progress and more frustrating. They will generally be more rewarding as you will know that you have helped with a fundamental part of Thousand Parsec and every one else is doing work based on yours.

Write a protocol compliance test suite

Currently protocol libraries have no way of testing their compliance with the protocol specification. Your job would be to write a suite which runs a protocol library through a bunch of tests and report on it's compliance.

More Information

Protocol 3

Required Skills

Some experience with testing is a must

Design and Implement a Research Framework

A general research framework is not designed yet. Design it...

You need to be able to support a wide variety of research rules, technology items and similar. Some rulesets feature randomly generated technology, others have a fixed list. Different trees for different races/players is also a common feature. Variable tech levels (Weapons vs Construction) must be supported as well technology with different requirements.

Obviously this requires extensions to the TP protocol - it's the main feature. Also you will need to expand a client and server to support it, along with an example in a ruleset. Once again this may be good to do in a group with someone else implementing the core rules why you focus on this aspect.

More Information

Discussion of the next Thousand Parsec protocol.

Required Skills

Good Python or C++ Skills

Python Stuff

Thousand Parsec uses a lot of python. These projects are generally to do with improve some python part of Thousand Parsec.

Add testing to libtpproto-py

The python library currently as no testing. It's your job to write enough tests that at least 60% of the code has proper testing.

More Information

libtpproto-py

Required Skills

Some experience with unit testing and Python is a must

Improve wxWidget's pyAUI

The next version of tpclient-pywx, the primary Thousand Parsec client is heavily dependent on pyAUI. There are a bunch of improvements which could be added to make pyAUI even better. Some examples are,

  • Minimise button support
  • Add better way to align the windows initially
  • Add better support for using floating MDI children under Windows
  • Add support for "fly out" windows (IE Windows which only show themselves when moused over)
  • Tab-based MDI classes (see C++ AUI)
  • Vertical Title bars
Feel free to add more ideas, a good place to look is wxAUI Forums.

More Information

PyAUI
tpclient-pywx Development Branch

Required Skills

Good Python skills is a must

Implement a new Ruleset

Thousand Parsec's greatest strength is that it is a protocol for describing games, not a single game ruleset. Obviously then the more (complete) rulesets the better.

You can choose to implement the rulesets in either the Python Server or in the C++ Server. Both servers currently only implement MiniSec but have been designed to support a wide variety of other rulesets.

All these tasks will require C++ skills (if developing for the C++ Server) or Python (if developing for the Python Server). You may need to do some work on the core of the server if you are doing more advanced stuff too.

Implement MTSec prototype Ruleset

MTSec (short for Missile and Torpedo Wars) is a simple game designed to flex the ship and weapon design capabilities of Thousand Parsec. It is the first ruleset to have a simple economy and should be more interesting then the first prototype game MiniSec.

More Information

MTSec Documentation
SF Todo Tracker Item

Required Skills

C++ skills or Python skill.

Implement "Reach for the Stars" Clone

In 1981 SSI released "Reach for the Stars", a classic in the 4X genre. The rules for the game itself were fairly simple - in the mechanics for everything except combat were in the rule book. It allowed up to 4 players, although it lacked decent network play (not a surprise -- the internet as we know it was quite a few years in the future).

TP is currently at a stage were most, if not all, of RFTS can be implemented in the current protocol. The game itself was balanced (by virtue of identical races) but had more then enough depth to keep players coming back.

The goal of this project is to implement RFTS as a TP ruleset in any server. Additionally you may need to make adjustments to a client to support it. The RFTS AI's are a challenge for the truly adventurous.

A new version of RFTS was released some years later. It also could be used as a ruleset, however it is a much more ambitous project, and would require a lot of work to expand the TP protocol.

More Information

Wikipedia Page

Required Skills

Good Python or C++ Skills

Implement "Diplomancy... In Space" Clone

One of the greatest board (and later computer) games is Avalon Hills Diplomacy game. Focusing on diplomacy between the players, forcing them to ally, lie, cheat, support and often backstab each other the game was (and is) a classic. Without the diplomacy aspect it becomes a fairly average war game - with the diplomacy aspect, it's simple support-based combat system, secret orders and general tight confines make for an engaging and deep gaming experience.

TP itself is missing some basic in turn messaging, but otherwise a ruleset using some of the ideas from Diplomacy to create fairly simple diplomatic game - in space could be done. Some work on how to turn adjacent countries/territories into space fleets need to done.

The goal of this project is to implement a Diplomacy style game - one focused on shifting alliances and political manoeuvring, rather then pure military might. Messaging between players will need to implemented in a server and client, and minor protocol adjustments will need to be made to allow messaging between players.

More Information

Wikipedia Page

Required Skills

Good Python or C++ Skills

Mentors

There are also the following mentors, but they are smart enough not to disclose their details to the public.

  • Matthew Draper (matthewd)
    • Responsible for: All Ruby code (such as libtpproto-rb), Improvements to protocol.xml
  • Jotham Read (jothamd)
    • Responsible for: Battleviewer, Some Artwork
  • Tam Ho Wai Howell (pigeond)
    • Responsible for: Mobile/Embedded Gui, Graphics, Play testing

Deadlines and Dates

March 14
List of accepted mentoring organizations published on code.google.com; student application period opens
March 26
Student application deadline
April 11
List of accepted student applications published on code.google.com
May 28
Students begin coding for their GSoC projects; Google begins issuing initial student payments
July 9
Students upload code to code.google.com/hosting; mentors begin mid-term evaluations
July 16
Mid-term evaluation deadline; Google begins issuing mid-term student payments
August 20
Students upload code to code.google.com/hosting; mentors begin final evaluations; students begin final program evaluations
August 31
Final evaluation deadline; Google begins issuing student and mentoring organization payments

Thanks

We would like to thank the following people,

  • Creative Commons - a lot of the information in this document was adapted from their Summer of Code page.
  • Inkscape - the Inkscape project also has a large amount of stuff which was useful in creating this page.
  • Google - without Google this wouldn't even be possible.