game_client.py

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