more_twisted.py

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