[pygame] SOC Proposal: Networking for Pygame

[Bryce Allen <pygame@xxxxxxxxxx>]

Hello,

I'm a student interested in working on Pygame for Google's Summer of Code. I'm 
working on a proposal to add an event based networking framework to Pygame, 
inspired by this Wiki entry:

http://wiki.python.org/moin/SummerOfCode/PythonLibraries/SimpleNetworkingForPygame

The latest version of my proposal lives here:
http://www.mumstudents.org/~bda/soc/NetworkingForPygame.html

I'm including my first draft below. Let me know what you think!

Thanks,
Bryce Allen


* Proposal

Create a networking framework for Pygame which integrates into the event 
queue, using the Python socket API. The framework will include both 
peer-to-peer networking and game discovery via a game server or local 
broadcast.

* Acknowledgements

http://wiki.python.org/moin/SummerOfCode/PythonLibraries/SimpleNetworkingForPygame

This proposal builds on ideas from the Summer of Code wiki. Thanks to all the 
contributers!


* Details
 
Games have very different requirements in terms of networking - typically each 
game defines it's own high level protocol. However, there are common needs 
which may be shared among multiple games. Creating an inheritance hiearchy of 
protocols would promote reuse of protocol layers, and provide a convenient 
way to parsel off networking code. The events posted to the queue would 
depend on which protocol is initialized.

I think the most useful mid-level protocol which would satisfy the needs of 
most games is a TCP based remote events protocol like dkeeney suggested (see 
the wiki link above). TCP is the easiest way to get reliable delivery. 
However, a UDP version could also be developed with a more lightweight 
connection management system, and it could be swapped in seamlessly if it 
emits the same events.

TCP and UDP protocols would mainly be used by people implementing their own 
special purpose protocol. Creating a new protocol object inheriting from TCP 
or UDP and posting custom events would be encouraged, rather then using the 
TCP or UDP events directly. However, for simple games using the TCP/UDP 
events directly could be convenient.

Game discovery could also be implemented through pluggable classes. Specific 
games could extend the basic classes with support for searching for games 
with specific options set, for example.

Higher level protocols, like the remote events protocol, would have it's own 
(possibly pluggable) serialization. TCP and UDP would accept strings only, as 
suggested in the wiki. I think it is important to provide a simple safe 
serializer to discourage people from using pickle.


* Potential API

# find a game to join
discovery = pygame.network.discovery.GameServer(gameGUID, server)
discovery = pygame.network.discovery.LocalBroadcast(gameGUID, server)

# blocking version
gameDescriptors = discovery.list_games()

# event queue version
discover.start_search()

# initialize the network with a given protocol object
connection = gameDescriptor.get_connection() # from the game descriptor
connection = pygame.network.TCPRemoteEvents(CLIENT, serverAddr)
pygame.network.init(connection)

connection.start()

# after we've gotten a connect event, we can send data
connection.send(event) # in the case of TCPRemoteEvents, we send events

# using it
pygame.network.pump_events()
pygame.network.discovery.pump_events()

# some example events
for event in pygame.events.get()
    if e.type == NET:
        if e.what == NET_CONNECT:
            startGame()
    if e.type == NET_DISCOVERY:
        if e.what == NET_DISCOVERY_GAME_FOUND:
            # update display with available games
            print e.protocol
            print e.connection_arguments
            print e.options
    if e.type == KEYDOWN:
        if e.key == player1.keys.up:
            connection.send(Event(MyGlobals.PLAYER_MOVE_EVENT, {"player" : 
1, "direction": Direction.UP} )



* Protocol Inheritance

# When inheriting from TCP or UDP, you can choose to pass or consume the TCP 
events and add new events

# this would consume the standard TCP DATA_IN event and parse the data into an 
event object, then post the remote event to the local queue
pygame.network.init(TCPRemoteEvents(CLIENT, serverAddr))