client_twisted.py

   1 #!/usr/bin/python
   2
   3 # PyOpenGL + Pygame
   4
   5 # various constants
   6
   7 CONFIG = 'game_config.xml'
   8 PROTOCOL_FILE = 'protocol.py'
   9
  10 WINDOW_SIZE = (640, 480)
  11 WINDOW_CAPTION = "Testing stuff"
  12
  13 BROADCAST = 50030
  14 BROADCAST_BIND = 50031
  15
  16 MESSAGE = 40030
  17 BUFSIZE = 120
  18 ECHO_TIME = 5
  19 TIMEOUT = .1
  20 BROADCAST = ''
  21 MULTICAST = '234.0.0.1'
  22 SERVER_TIMEOUT = 0
  23
  24 protocol_file = open(PROTOCOL_FILE)
  25 exec(protocol_file)
  26 protocol_file.close()
  27
  28 the_functions = {}
  29 in_script = 0
  30
  31 import os, sys
  32 from os import *
  33 from os.path import *
  34 sys.path.insert(0, 'pygame_gui')
  35
  36 import threading
  37 from socket import *
  38 from xml.dom.minidom import parse, parseString
  39 from threading import Lock
  40 from signal import *
  41 from zipfile import *
  42
  43 from twisted.internet.protocol import DatagramProtocol
  44 from twisted.internet import reactor
  45 from twisted.internet import task
  46
  47 import pygame
  48 from pygame import *
  49
  50 import lamina
  51
  52 import OpenGL
  53 import OpenGL.GL
  54 from OpenGL.GL import *
  55 import OpenGL.GLU
  56 from OpenGL.GLU import *
  57
  58 from DerGUI import GUISystem
  59
  60 the_event_receiver = 0
  61
  62 global the_engine
  63 global the_client
  64
  65 class Engine:
  66
  67     def __init__(self, config):
  68
  69         self.config = config
  70         self.running = 1
  71
  72         global the_engine
  73         the_engine = self
  74
  75         video_flags = OPENGL|DOUBLEBUF
  76
  77         pygame.init()
  78         self.display = pygame.display.set_mode(config['window_size'], video_flags)
  79         self.resize((config['window_size']))
  80
  81         glShadeModel(GL_SMOOTH)
  82         glClearColor(self.config['background_color'][0],
  83                      self.config['background_color'][1],
  84                      self.config['background_color'][2],
  85                      self.config['background_color'][3])
  86
  87         glClearDepth(1.0)
  88         glEnable(GL_DEPTH_TEST)
  89         glDepthFunc(GL_LEQUAL)
  90         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
  91
  92         pygame.display.set_caption(config['window_title'])
  93
  94         self.gui_screen = lamina.LaminaScreenSurface()
  95
  96         self.gui_system = GUISystem('widgets.xml', 'theme_two.zip')
  97         self.change = 0
  98
  99         self.files = {}
 100         self.events = EventReceiver()
 101
 102         # self.files is a map of filename to file
 103
 104         # The file has this:
 105         #  {parent, [children], {object_defs},
 106         #  {menu_defs}, {object_instances}, {menu_instances}}
 107
 108         self.zipfiles = []
 109
 110         for file in listdir(self.config['pack_dir']):
 111             if (is_zipfile(os.path.join(self.config['pack_dir'], file))):
 112                 self.zipfiles.append(ZipFile(os.path.join(self.config['pack_dir'], file)))
 113
 114         self.running = self.addFile(self.config['init'], '')
 115
 116         if not self.running:
 117             print "Engine.__init__(): Failed adding initial file"
 118
 119         return
 120
 121     def run(self):
 122
 123         global the_client
 124
 125         self.gui_screen.refresh()
 126
 127         while self.running:
 128
 129             self.process_events()
 130
 131             self.draw()
 132
 133             pygame.display.flip()
 134
 135         return
 136
 137     def killGame(self):
 138
 139         reactor.callFromThread(self.killThreadGame)
 140
 141         return
 142
 143     def killThreadGame(self):
 144
 145         reactor.stop()
 146
 147         return
 148
 149     def process_events(self):
 150
 151         change = 0
 152
 153         for e in pygame.event.get():
 154             if e.type == QUIT:
 155                 self.running = 0
 156                 print "Should be quitting..."
 157
 158                 self.killGame()
 159
 160             self.change = self.gui_system.event(e)
 161
 162             new_event = self.convertEvent(e)
 163             self.events.addEvent(new_event)
 164
 165         iterating = 1
 166         while iterating:
 167
 168             if self.events.size():
 169                 new_event = self.events.getEvent()
 170             else:
 171                 iterating = 0
 172
 173             if not iterating:
 174                 return
 175
 176             if iterating:
 177                 for file in self.files.keys():
 178
 179                     for name in self.files[file]['object_instances'].keys():
 180
 181                         self.files[file]['object_instances'][name].event(new_event[0], new_event[1])
 182
 183         return
 184
 185     def convertEvent(self, e):
 186
 187         data = {}
 188
 189         if e.type == QUIT:
 190             data['none'] = ''
 191
 192         if e.type == ACTIVEEVENT:
 193             data['gain'] = e.gain
 194             data['state'] = e.state
 195
 196         if e.type == KEYDOWN:
 197             data['unicode'] = e.unicode
 198             data['key'] = e.key
 199             data['mod'] = e.mod
 200
 201         if e.type == KEYUP:
 202             data['key'] = e.key
 203             data['mod'] = e.mod
 204
 205         if e.type == MOUSEMOTION:
 206             data['pos'] = e.pos
 207             data['rel'] = e.rel
 208             data['buttons'] = e.buttons
 209
 210         if e.type == MOUSEBUTTONUP:
 211             data['pos'] = e.pos
 212             data['button'] = e.button
 213
 214         if e.type == MOUSEBUTTONDOWN:
 215             data['pos'] = e.pos
 216             data['button'] = e.button
 217
 218         if e.type == JOYAXISMOTION:
 219             data['joy'] = e.joy
 220             data['axis'] = e.axis
 221             data['value'] = e.value
 222
 223         if e.type == JOYBALLMOTION:
 224             data['joy'] = e.joy
 225             data['ball'] = e.ball
 226             data['rel'] = e.rel
 227
 228         if e.type == JOYHATMOTION:
 229             data['joy'] = e.joy
 230             data['hat'] = e.hat
 231             data['value'] = e.value
 232
 233         if e.type == JOYBUTTONUP:
 234             data['joy'] = e.joy
 235             data['button'] = e.button
 236
 237         if e.type == JOYBUTTONDOWN:
 238             data['joy'] = e.joy
 239             data['button'] = e.button
 240
 241         if e.type == VIDEORESIZE:
 242             data['size'] = e.size
 243             data['w'] = e.w
 244             data['h'] = e.h
 245
 246         if e.type == VIDEOEXPOSE:
 247             data['none'] = ''
 248
 249         if e.type == USEREVENT:
 250             data['code'] = e.code
 251
 252         type = ''
 253
 254         if e.type == QUIT: type = "QUIT"
 255         if e.type == ACTIVEEVENT: type = "ACTIVEEVENT"
 256         if e.type == KEYDOWN: type = "KEYDOWN"
 257         if e.type == KEYUP: type = "KEYUP"
 258         if e.type == MOUSEMOTION    : type = "MOUSEMOTION"
 259         if e.type == MOUSEBUTTONUP: type = "MOUSEBUTTONUP"
 260         if e.type == MOUSEBUTTONDOWN: type = "MOUSEBUTTONDOWN"
 261         if e.type == JOYAXISMOTION: type = "JOYAXISMOTION"
 262         if e.type == JOYBALLMOTION: type = "JOYBALLMOTION"
 263         if e.type == JOYHATMOTION: type = "JOYHATMOTION"
 264         if e.type == JOYBUTTONUP: type = "JOYBUTTONUP"
 265         if e.type == JOYBUTTONDOWN: type = "JOYBUTTONDOWN"
 266         if e.type == VIDEORESIZE: type = "VIDEORESIZE"
 267         if e.type == VIDEOEXPOSE: type = "VIDEOEXPOSE"
 268         if e.type == USEREVENT: type = "USEREVENT"
 269
 270         return [type, data]
 271
 272     def draw(self):
 273
 274         glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
 275         glLoadIdentity()
 276
 277         # draw stuff
 278
 279         glLoadIdentity()
 280
 281         if self.change:
 282             self.gui_system.draw(self.gui_screen.surf)
 283             self.gui_screen.refresh()
 284         self.gui_screen.display()
 285
 286     def resize(self, (width, height)):
 287         if height==0:
 288             height=1
 289         glViewport(0, 0, width, height)
 290         glMatrixMode(GL_PROJECTION)
 291         glLoadIdentity()
 292         gluPerspective(45, 1.0*width/height, 0.1, 100.0)
 293         glMatrixMode(GL_MODELVIEW)
 294         glLoadIdentity()
 295
 296         return
 297
 298     def addFile(self, filename, parent):
 299
 300       # Because I have alot of nesting in this function,
 301       # I am using 2 space formatting
 302
 303       for zipfile in self.zipfiles:
 304
 305         for file in zipfile.namelist():
 306
 307           if (file == filename):
 308             dom = parseString(zipfile.read(file))
 309
 310             object_instances_d = []
 311             menu_instances = []
 312
 313             if dom.childNodes[0].nodeName == 'game':
 314               self.files[filename] = {
 315                   'object_defs': {},
 316                   'children': [],
 317                   'parent': '',
 318                   'object_instances': {},
 319                   'menu_instances': {},
 320                   'menu_defs': {}}
 321
 322               for node in dom.childNodes[0].childNodes:
 323
 324                 if (node.nodeName == 'def'):
 325
 326                   for sub_node in node.childNodes:
 327
 328                     if (sub_node.nodeName == 'object'):
 329
 330                       temp_object_def = {}
 331
 332                       for suber_node in sub_node.childNodes:
 333
 334                         if (suber_node.nodeName == 'name'):
 335                           if len(suber_node.childNodes):
 336                             temp_object_def['name'] = suber_node.childNodes[0].nodeValue
 337
 338                         if (suber_node.nodeName == 'script'):
 339                           if len(suber_node.childNodes):
 340                             temp_object_def['script'] = suber_node.childNodes[0].nodeValue
 341
 342                         if (suber_node.nodeName == 'tangible'):
 343                           if len(suber_node.childNodes):
 344                             temp_object_def['tangible'] = suber_node.childNodes[0].nodeValue
 345
 346                         if (suber_node.nodeName == 'type'):
 347                           if len(suber_node.childNodes):
 348                             temp_object_def['type'] = suber_node.childNodes[0].nodeValue
 349
 350                       self.files[filename]['object_defs'][temp_object_def['name']] = temp_object_def
 351                       temp_object_def = {}
 352
 353                     if (sub_node.nodeName == 'menu'):
 354
 355                       temp_menu_def = {}
 356                       temp_menu_def['elements'] = {}
 357
 358                       temp_element_set = {}
 359
 360                       for suber_node in sub_node.childNodes:
 361
 362                         if (suber_node.nodeName == 'name'):
 363                           temp_menu_def['name'] = suber_node.childNodes[0].nodeValue
 364
 365                         if (suber_node.nodeName == 'elements'):
 366
 367                           for suberer_node in suber_node.childNodes:
 368
 369                             if (suberer_node.nodeType != 3 and suberer_node.nodeType != 8):
 370                               if (suberer_node.hasAttribute('name')):
 371                                 temp_element_set['name'] = suberer_node.getAttribute('name')
 372
 373                               if (suberer_node.hasAttribute('x')):
 374                                 temp_element_set['x'] = int(suberer_node.getAttribute('x'))
 375
 376                               if (suberer_node.hasAttribute('y')):
 377                                 temp_element_set['y'] = int(suberer_node.getAttribute('y'))
 378
 379                               if (suberer_node.hasAttribute('width')):
 380                                 temp_element_set['width'] = int(suberer_node.getAttribute('width'))
 381
 382                               if (suberer_node.hasAttribute('height')):
 383                                 temp_element_set['height'] = int(suberer_node.getAttribute('height'))
 384
 385                               if (suberer_node.hasAttribute('parent')):
 386                                 temp_element_set['parent'] = suberer_node.getAttribute('parent')
 387
 388                               if (suberer_node.hasAttribute('target')):
 389                                 temp_element_set['target'] = suberer_node.getAttribute('target')
 390
 391                               if (suberer_node.hasAttribute('text')):
 392                                 temp_element_set['text'] = suberer_node.getAttribute('text')
 393
 394                               temp_element_set['type'] = suberer_node.nodeName
 395                               temp_menu_def['elements'][temp_element_set['name']] = temp_element_set
 396                               temp_element_set = {}
 397
 398                       self.files[filename]['menu_defs'][temp_menu_def['name']] = temp_menu_def
 399
 400                       temp_menu_def = {}
 401                       temp_element_set = {}
 402
 403                 if (node.nodeName == 'instance'):
 404
 405                   for sub_node in node.childNodes:
 406
 407                     if (sub_node.nodeName == 'object'):
 408                       object_instances_d.append(sub_node.childNodes[0].nodeValue)
 409
 410                     if (sub_node.nodeName == 'menu'):
 411                       menu_instances.append(sub_node.childNodes[0].nodeValue)
 412
 413             if (parent != ''):
 414               self.files[parent]['children'].append(filename)
 415             self.files[filename]['parent'] = parent
 416
 417             # create instances
 418
 419             for menuname, menu_data in self.files[filename]['menu_defs'].iteritems():
 420               self.files[filename]['menu_instances'][menuname] = Menu(menu_def=menu_data)
 421
 422             for menuname in menu_instances:
 423               if (self.files[filename]['menu_instances'].has_key(menuname)):
 424                 self.files[filename]['menu_instances'][menuname].show()
 425
 426               for file in self.files.keys():
 427                 if self.files[file]['menu_instances'].has_key(menuname):
 428                   self.files[file]['menu_instances'][menuname].show()
 429
 430             for objectname in object_instances_d:
 431               self.addObject(objectname)
 432
 433             return 1
 434       return 0
 435     # ending 2-space formatting
 436
 437     def removeFile(self, filename):
 438
 439         if (self.files.has_key(filename)):
 440
 441             for child in self.files[filename]['children']:
 442                 self.removeFile(child)
 443
 444             del self.files[filename]['children']
 445
 446             parent = self.files[filename]['parent']
 447
 448             self.files[parent]['children'].pop(self.files[parent]['children'].index(filename))
 449
 450             del self.files[filename]
 451
 452         return
 453
 454     def getVisibleMenus(self):
 455
 456         menus = {}
 457
 458         for file, contents in self.files.iteritems():
 459             for name, menu in contents['menu_instances'].iteritems():
 460                 if not menu.hidden:
 461                     menus[name] = menu
 462
 463         return menus
 464
 465     def hideAllMenus(self):
 466
 467         for file, contents in self.files.iteritems():
 468             for name, menu in contents['menu_instances'].iteritems():
 469                 menu.hide()
 470
 471         return
 472
 473     def showMenu(self, menu_name):
 474
 475         for file, contents in self.files.iteritems():
 476             for name, menu in contents['menu_instances'].iteritems():
 477                 if contents['menu_instances'].has_key(menu_name):
 478                     contents['menu_instances'][menu_name].show()
 479
 480         return
 481
 482     def hideMenu(self, menu_name):
 483
 484         for file, contents in self.files:
 485             for name, menu in contents['menu_instances'].iteritems():
 486                 if contents['menu_instances'].has_key(menu_name):
 487                     contents['menu_instances'][menu_name].hide()
 488
 489         return
 490
 491     def setMenu(self, menu_name):
 492
 493         self.hideAllMenus()
 494         self.showMenu(menu_name)
 495
 496         return
 497
 498     def addObject(self, objectname):
 499
 500         for file in self.files.keys():
 501             if self.files[file]['object_defs'].has_key(objectname):
 502                 self.files[file]['object_instances'][objectname] = GameObject(
 503                     self.files[file]['object_defs'][objectname])
 504
 505         return
 506
 507     def removeObject(self, objectname):
 508
 509         for file in self.files.keys():
 510             if self.files[file]['object_defs'].has_key(objectname):
 511                 del self.files[file]['object_instances'][objectname]
 512
 513         return
 514
 515     def addListItem(self, menuname, item, data, dvalue):
 516
 517         print "Engine.addListItem(): Not implemented yet."
 518
 519         return
 520
 521     def getImage(self, filename):
 522
 523         the_buf = pygame.image.load(self.getStringIOFile(filename))
 524
 525         return the_buf
 526
 527     def getStringIOFile(self, filename):
 528
 529         for zip_file in self.zipfiles:
 530             for file in zip_file.namelist():
 531
 532                 if (filename == file):
 533
 534                     the_string_io = StringIO.StringIO()
 535                     print >>the_string_io, zip_file.read(file)
 536                     the_string_io.seek(0)
 537
 538                     return the_string_io
 539         return ''
 540
 541     def getStringData(self, filename):
 542         for zip_file in self.zipfiles:
 543             for file in zip_file.namelist():
 544
 545                 if (filename == file):
 546                     return zip_file.read(file)
 547         return ''
 548
 549 class Menu:
 550
 551     def __init__(self, menu_def):
 552
 553         self.menu_def = menu_def
 554         self.widgets = {}
 555
 556         self.gui_system = the_engine.gui_system
 557
 558         for name, element in menu_def['elements'].iteritems():
 559
 560             multiplier_x = float(the_engine.config['window_size'][0]) / 100
 561             multiplier_y = float(the_engine.config['window_size'][1]) / 100.00
 562
 563             dx = float(element['x']) * multiplier_x
 564             dy = float(element['y']) * multiplier_y
 565
 566             dwidth = float(element['width']) * multiplier_x
 567             dheight = float(element['height']) * multiplier_y
 568
 569             params = {'x': dx, 'y': dy, 'width': dwidth, 'height': dheight }
 570
 571             if element['type'] == 'image':
 572                 print "Widget.__init__(): 'image' widget type not implemented yet."
 573
 574             if element['type'] == 'label':
 575                 params['text'] = element['text']
 576                 self.widgets[name] = self.gui_system.makeWidget('label', params)
 577
 578             if element['type'] == 'button':
 579                 params['text'] = element['text']
 580                 self.widgets[name] = self.gui_system.makeWidget('button', params)
 581                 self.widgets[name].connect('BUTTON_CLICKED', self.clicked, {'name': name})
 582
 583             if element['type'] == 'listbox':
 584                 print "Widget.__init__(): 'listbox' widget type not implemented yet."
 585
 586             if element['type'] == 'textbox':
 587                 params['type'] == element['text']
 588                 self.widgets[name] = self.gui_system.makeWidget('textbox', params)
 589                 self.widgets[name].connect('KEYDOWN', self.key_pressed, {'name': name})
 590
 591         self.hidden = 0
 592
 593         return
 594
 595     def show(self):
 596
 597         for widget in self.widgets:
 598             self.widgets[widget].show()
 599
 600         self.hidden = 0
 601
 602         return
 603
 604     def hide(self):
 605
 606         for widget in self.widgets:
 607             self.widgets[widget].hide()
 608
 609         self.hidden = 1
 610
 611         return
 612
 613     def clicked(self, params, more_params):
 614
 615         #if self.menu_def['elements'].has_key()
 616         # to be continued
 617
 618         return
 619
 620 class GameObject:
 621
 622     def __init__(self, dmold):
 623
 624         self.mold = dmold
 625         global the_functions
 626         global in_script
 627
 628         if self.mold['script'] != '':
 629
 630             in_script = 1
 631
 632             the_file = the_engine.getStringData(self.mold['script'])
 633             if the_file != '':
 634                 exec(the_file)
 635
 636             in_script = 0
 637             self.my_functions = the_functions
 638
 639             the_functions = {}
 640
 641     def event(self, event, data):
 642
 643         if self.my_functions.has_key(event):
 644
 645             self.my_functions[event](data)
 646
 647         return
 648
 649 class Multicast(DatagramProtocol):
 650
 651     def startProtocol(self):
 652         self.transport.joinGroup(MULTICAST)
 653
 654     def datagramReceived(self, datagram, address):
 655
 656         pass
 657
 658 class QueueLock:
 659     def __init__(self):
 660
 661         self.items = []
 662         self.items_lock = Lock()
 663
 664     def size(self):
 665
 666         return len(self.items)
 667
 668     def getItem(self):
 669
 670         self.items_lock.acquire()
 671         the_item = self.items.pop(0)
 672         self.items_lock.release()
 673
 674         return the_item
 675
 676     def addItem(self, new_item):
 677
 678         self.items_lock.acquire()
 679         self.items.append(new_item)
 680         self.items_lock.release()
 681
 682         return
 683
 684 class EventReceiver(QueueLock):
 685
 686     def getEvent(self):
 687         return self.getItem()
 688     def addEvent(self, event):
 689
 690         self.addItem(event)
 691         return
 692
 693 class CommandLine(QueueLock):
 694
 695     def getCommand(self):
 696         return self.getItem()
 697     def addCommand(self, command):
 698         self.addItem(command)
 699         return
 700
 701 class Client(DatagramProtocol):
 702
 703     def datagramReceived(self, data, (host, port)):
 704
 705         if data[:len(YOUTHERE)] == YOUTHERE:
 706
 707 #            print "Client.datagramReceived(): Recieved YOUTHERE, responding with IMHERE"
 708             self.transport.write(IMHERE, (host, port))
 709
 710         if data[:len(SERVEROFFER)] == SERVEROFFER:
 711
 712             split_strings = data.split()
 713
 714             self.servers[split_strings[2]] = (host, int(split_strings[1]))
 715
 716             event = [SERVEROFFER, {'server_name': split_strings[2],
 717                                    'server_address': self.servers[split_strings[2]]}]
 718             the_engine.events.addEvent(event)
 719
 720             print "Client.datagramReceived(): Received SERVEROFFER"
 721
 722         if data[:len(YOUREIN)] == YOUREIN:
 723
 724             if (host, port) == self.requested_server:
 725                 self.current_server = (host, port)
 726                 self.requested_server = ()
 727
 728                 event = [YOUREIN]
 729                 data = {'server': self.current_server}
 730                 event.append(data)
 731
 732                 the_engine.events.addEvent(event)
 733
 734                 print "Client.datagramReceived(): Received YOUREIN, joined server"
 735
 736                 return
 737
 738         if data[:len(LIST)] == LIST:
 739
 740             print "Client.datagramReceived(): Received LIST"
 741
 742             split_strings = data.split()
 743
 744             self.members = []
 745
 746             for string in split_strings:
 747                 if string != LIST:
 748                     self.members.append(string)
 749
 750             event = [LIST]
 751             data = {'names': self.members, 'server_address': (host, port)}
 752             event.append(data)
 753
 754             the_engine.events.addEvent(event)
 755
 756             return
 757
 758         if data[:len(SOMEONEJOINED)] == SOMEONEJOINED:
 759
 760             if (host, port) == self.current_server:
 761
 762                 print "Client.datagramReceived(): Received SOMEONEJOINED"
 763
 764                 left_member = ''
 765
 766                 for member in self.members:
 767                     if member == data[len(SOMEONEJOINED) + 1:]:
 768                         left_member = member
 769
 770                 if left_member == '':
 771                     self.members.append(data[len(SOMEONEJOINED) + 1:])
 772
 773                     event = [SOMEONEJOINED]
 774                     data = {'name': data[len(SOMEONEJOINED) + 1:]}
 775
 776                     event.append(data)
 777
 778                     the_engine.events.addEvent(event)
 779
 780             return
 781
 782         if data[:len(SOMEONELEFT)] == SOMEONELEFT:
 783
 784             if (host, port) == self.current_server:
 785
 786                 name = data[len(SOMEONELEFT) + 1:]
 787
 788                 if name in self.members:
 789                     print "Client.datagramReceived(): Received SOMEONELEFT"
 790
 791                     self.members.remove(name)
 792
 793                     event = [SOMEONELEFT]
 794                     data = {'name': name}
 795
 796                     event.append(data)
 797
 798                     the_engine.events.addEvent(event)
 799
 800                 else:
 801                     print "Client.datagramReceived(): Received SOMEONELEFT, but", name, "not present in roster"
 802
 803                 return
 804
 805         if data[:len(YOUROUT)] == YOUROUT:
 806
 807             if (host, port) == self.current_server:
 808
 809                 print "Client.datagramReceived(): Recieved YOUROUT"
 810
 811                 self.current_server = ()
 812
 813                 event = [YOUROUT]
 814                 data = {}
 815                 event.append(data)
 816
 817                 the_engine.events.addEvent(event)
 818
 819                 return
 820
 821         if data[:len(LETTER)] == LETTER:
 822
 823             if (host, port) == self.current_server:
 824                 print "Client.datagramReceived(): Received LETTER"
 825
 826                 split_strings = data.split(':')
 827
 828                 message = data[data.find(':', len(LETTER) + 1) + 1:]
 829                 message_origin = split_strings[1]
 830
 831                 event = [LETTER]
 832                 data = {'message': message, 'origin': message_origin}
 833                 event.append(data)
 834
 835                 the_engine.events.addEvent(event)
 836
 837                 return
 838
 839         if data[:len(IMHERE)] == IMHERE:
 840
 841             if (host, port) == self.current_server:
 842                 print "Client.datagramReceived(): Received IMHERE from server"
 843
 844                 self.server_request = 0
 845
 846         return
 847
 848     def init(self, params):
 849
 850         self.params = params
 851
 852         self.current_server = ()
 853         self.requested_server = ()
 854         self.servers = {}
 855
 856         self.inited = 1
 857
 858         return
 859
 860     def serverRequest(self):
 861
 862         if self.current_server != ():
 863
 864             if self.server_request > SERVER_TIMEOUT:
 865                 the_engine.events.addEvent([SERVER_GONE, {}])
 866                 self.current_server = ()
 867
 868             else:
 869                 self.server_request += 1
 870                 self.transport.write(YOUTHERE, self.current_server)
 871
 872         return
 873
 874     def executeCommand(self, command, data):
 875
 876         reactor.callFromThread(self.executeThreadedCommand, command, data)
 877
 878         return
 879
 880     def executeThreadedCommand(self, command, data):
 881         if command == SERVERKILL:
 882
 883             if self.current_server != ():
 884
 885                 message = ''.join([SERVERKILL, ' '])
 886
 887                 if data.has_key('password'):
 888                     message = ''.join([message, data['password']])
 889
 890                 self.transport.write(message, self.current_server)
 891
 892         if command == SERVERREQUEST:
 893
 894             message = ''.join([SERVERREQUEST, ' ', str(self.params['message_port'])])
 895
 896             the_multicast.transport.write(message, (MULTICAST, self.params['broadcast_port']))
 897 #            self.transport.write(message, ('255.255.255.255', self.params['broadcast_port']))
 898
 899         if command == GETLIST:
 900
 901             message = GETLIST
 902
 903             if data.has_key('server'):
 904
 905                 if self.servers.has_key(data['server']):
 906                     self.transport.write(message, self.servers[data['server']])
 907
 908             else:
 909
 910                 if self.current_server != ():
 911                     self.transport.write(message, self.current_server)
 912
 913         if command == IMOUT:
 914
 915             if self.current_server != ():
 916
 917                 message = IMOUT
 918
 919                 self.transport.write(message, self.current_server)
 920
 921                 self.current_server = ()
 922
 923         if command == LETTER:
 924
 925             if self.current_server != ():
 926
 927                 message = ''.join([LETTER, ':'])
 928
 929                 for dest in data['destinations']:
 930                     if dest in self.members:
 931                         message = ''.join([message, ' ' , dest])
 932
 933                 message = ''.join([message, ':', data['message']])
 934
 935                 self.transport.write(message, self.current_server)
 936
 937         if command == WANTIN:
 938
 939             if data.has_key('server'):
 940                 if self.servers.has_key(data['server']):
 941
 942                     self.transport.write(''.join([WANTIN, ' ', self.params['name']]),
 943                                          self.servers[data['server']])
 944                     self.current_server = ()
 945                     self.requested_server = self.servers[data['server']]
 946
 947         return
 948
 949 def main():
 950
 951     if len(sys.argv) > 1:
 952         config = sys.argv[1]
 953     else:
 954         print "main(): No config specified, using", CONFIG
 955         config = CONFIG
 956
 957     configuration = parse_config(config)
 958
 959     if (configuration.has_key('error') and configuration['error']):
 960         print "main(): Error in parsing config."
 961
 962     the_event_receiver = EventReceiver()
 963
 964     global client_params
 965     client_params = {'broadcast_port':configuration['broadcast_port'],
 966                      'broadcast_bind':configuration['broadcast_bind'],
 967                      'message_port':configuration['message_port'],
 968                      'name':configuration['name'],
 969                      'echo_time': configuration['echo_time']}
 970
 971     global the_engine
 972     global the_client
 973
 974     the_engine = Engine(configuration)
 975
 976     the_client = Client()
 977     the_client_thread = threading.Thread(target=run_net)
 978
 979     the_client.server_request = 0
 980
 981     the_client.init(client_params)
 982
 983     the_client_thread.start()
 984     the_engine.run()
 985
 986     the_engine.killGame()
 987
 988     sys.exit()
 989
 990     the_client_thread.join()
 991
 992     return
 993
 994 def run_net():
 995
 996     global client_params
 997     global the_multicast
 998
 999     the_multicast = Multicast()
1000     config = client_params
1001
1002     reactor.listenMulticast(config['broadcast_bind'], the_multicast)
1003     reactor.listenUDP(config['message_port'], the_client)
1004
1005     echo_request = task.LoopingCall(the_client.serverRequest)
1006
1007     if client_params['echo_time'] != None:
1008         echo_request.start(client_params['echo_time'])
1009     else:
1010         print "run_net(): No ECHO_TIME specified, using default of", ECHO_TIME
1011         echo_request.start(ECHO_TIME)
1012
1013     reactor.run(installSignalHandlers=0)
1014
1015     return
1016
1017 def parse_config(filename):
1018     results = {'error': 1}
1019
1020     if (exists(filename)):
1021         dom = parse(filename)
1022     else:
1023         print "parse_config():", filename, "doesn't exist."
1024         return results
1025
1026     results = {'window_title': None,
1027                'log': None,
1028                'name': None,
1029                'font': None,
1030                'init': None,
1031                'message_port': None,
1032                'broadcast_port': None,
1033                'broadcast_bind': None,
1034                'fullscreen': None,
1035                'background_color': None,
1036                'window_size': None,
1037                'gravity': None,
1038                'step_size': None,
1039                'pack_dir': None,
1040                'echo_time': None}
1041
1042     if (dom.childNodes[0].nodeName == 'config'):
1043         for node in dom.childNodes[0].childNodes:
1044
1045             if (node.nodeName == 'window_title'):
1046                 results['window_title'] = node.childNodes[0].nodeValue
1047
1048             if (node.nodeName == 'log'):
1049                 results['log'] = node.childNodes[0].nodeValue
1050
1051             if (node.nodeName == 'name'):
1052                 results['name'] = node.childNodes[0].nodeValue
1053
1054             if (node.nodeName == 'font'):
1055                 results['font'] = node.childNodes[0].nodeValue
1056
1057             if (node.nodeName == 'init'):
1058                 results['init'] = node.childNodes[0].nodeValue
1059
1060             if (node.nodeName == 'message_port'):
1061                 results['message_port'] = int(node.childNodes[0].nodeValue)
1062
1063             if (node.nodeName == 'broadcast_port'):
1064                 results['broadcast_port'] = int(node.childNodes[0].nodeValue)
1065
1066             if (node.nodeName == 'broadcast_bind'):
1067                 results['broadcast_bind'] = int(node.childNodes[0].nodeValue)
1068
1069             if (node.nodeName == 'fullscreen'):
1070                 results['fullscreen'] = int(node.childNodes[0].nodeValue)
1071
1072             if (node.nodeName == 'background_color'):
1073
1074                 string_parts = node.childNodes[0].nodeValue.split()
1075                 results['background_color'] = [float(string_parts[0]), float(string_parts[1])]
1076                 results['background_color'].append(float(string_parts[2]))
1077                 results['background_color'].append(float(string_parts[3]))
1078
1079             if (node.nodeName == 'window_size'):
1080
1081                 string_parts = node.childNodes[0].nodeValue.split()
1082                 results['window_size'] = ((int(string_parts[0]), int(string_parts[1])))
1083
1084             if (node.nodeName == 'gravity'):
1085
1086                 string_parts = node.childNodes[0].nodeValue.split()
1087                 results['gravity'] = [float(string_parts[0]), float(string_parts[1])]
1088                 results['gravity'].append(float(string_parts[2]))
1089
1090             if (node.nodeName == 'step_size'):
1091                 results['step_size'] = float(node.childNodes[0].nodeValue)
1092
1093             if (node.nodeName == 'pack_dir'):
1094                 results['pack_dir'] = node.childNodes[0].nodeValue
1095
1096             if (node.nodeName == 'echo_time'):
1097                 results['echo_time'] = int(node.childNodes[0].nodeValue)
1098
1099     results['error'] = 0
1100
1101     return results
1102
1103 if __name__ == '__main__':
1104     main()