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                 return
 280
 281         if data[:len(IMHERE)] == IMHERE:
 282
 283             if (host, port) == self.current_server:
 284                 print "Client.datagramReceived(): Received IMHERE from server"
 285
 286                 self.server_request = 0
 287
 288         return
 289
 290     def init(self, params):
 291
 292         self.params = params
 293
 294         self.current_server = ()
 295         self.requested_server = ()
 296         self.servers = {}
 297
 298         self.inited = 1
 299
 300         return
 301
 302     def serverRequest(self):
 303
 304         if self.current_server != ():
 305
 306             if self.server_request > SERVER_TIMEOUT:
 307                 the_engine.events.addEvent([SERVER_GONE, {}])
 308                 self.current_server = ()
 309
 310             else:
 311                 self.server_request += 1
 312                 self.transport.write(YOUTHERE, self.current_server)
 313
 314         return
 315
 316     def executeCommand(self, command, data):
 317
 318         reactor.callFromThread(self.executeThreadedCommand, command, data)
 319
 320         return
 321
 322     def executeThreadedCommand(self, command, data):
 323         if command == SERVERKILL:
 324
 325             if self.current_server != ():
 326
 327                 message = ''.join([SERVERKILL, ' '])
 328
 329                 if data.has_key('password'):
 330                     message = ''.join([message, data['password']])
 331
 332                 self.transport.write(message, self.current_server)
 333
 334         if command == SERVERREQUEST:
 335
 336             message = ''.join([SERVERREQUEST, ' ', str(self.params['message_port'])])
 337
 338             the_multicast.transport.write(message, (MULTICAST, self.params['broadcast_port']))
 339 #            self.transport.write(message, ('255.255.255.255', self.params['broadcast_port']))
 340
 341         if command == GETLIST:
 342
 343             message = GETLIST
 344
 345             if data.has_key('server'):
 346
 347                 if self.servers.has_key(data['server']):
 348                     self.transport.write(message, self.servers[data['server']])
 349
 350             else:
 351
 352                 if self.current_server != ():
 353                     self.transport.write(message, self.current_server)
 354
 355         if command == IMOUT:
 356
 357             if self.current_server != ():
 358
 359                 message = IMOUT
 360
 361                 self.transport.write(message, self.current_server)
 362
 363                 self.current_server = ()
 364
 365         if command == LETTER:
 366
 367             if self.current_server != ():
 368
 369                 message = ''.join([LETTER, ':'])
 370
 371                 for dest in data['destinations']:
 372                     if dest in self.members:
 373                         message = ''.join([message, ' ' , dest])
 374
 375                 message = ''.join([message, ':', data['message']])
 376
 377                 self.transport.write(message, self.current_server)
 378
 379         if command == WANTIN:
 380
 381             if data.has_key('server'):
 382                 if self.servers.has_key(data['server']):
 383
 384                     self.transport.write(''.join([WANTIN, ' ', self.params['name']]),
 385                                          self.servers[data['server']])
 386                     self.current_server = ()
 387                     self.requested_server = self.servers[data['server']]
 388
 389         return
 390
 391 class Engine:
 392
 393     def __init__(self, config):
 394
 395         self.config = config
 396         self.running = 1
 397
 398         global the_engine
 399         the_engine = self
 400
 401         video_flags = OPENGL|DOUBLEBUF
 402
 403         pygame.init()
 404         self.display = pygame.display.set_mode(config['window_size'], video_flags)
 405
 406         self.font = pygame.font.SysFont("default", 18)
 407         self.fontBig = pygame.font.SysFont("default", 24)
 408         self.fontSub = pygame.font.SysFont("default", 20)
 409         self.theme = pgui.Theme(['test_theme', 'gray', 'default'])
 410 #        self.theme = pgui.Theme('gray')
 411 #        self.theme = pgui.Theme('default')
 412
 413         self.resize((config['window_size']))
 414
 415         glShadeModel(GL_SMOOTH)
 416         glClearColor(self.config['background_color'][0],
 417                      self.config['background_color'][1],
 418                      self.config['background_color'][2],
 419                      self.config['background_color'][3])
 420         glClearDepth(1.0)
 421         glEnable(GL_DEPTH_TEST)
 422         glDepthFunc(GL_LEQUAL)
 423         glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
 424
 425         pygame.display.set_caption(config['window_title'])
 426
 427         self.gui_screen = lamina.LaminaScreenSurface()
 428
 429         self.app = pgui.App(theme=self.theme)
 430         self.app._screen = self.gui_screen.surf
 431         self.main_container = pgui.Container(width=config['window_size'][0])
 432
 433         self.files = {}
 434
 435         self.events = EventReceiver()
 436
 437         # self.files is a map of filename to file
 438
 439         # The file has this:
 440         #  {parent, [children], {object_defs},
 441         #  {menu_defs}, {object_instances}, {menu_instances}}
 442
 443         self.zipfiles = []
 444
 445         for file in listdir(self.config['pack_dir']):
 446             if (is_zipfile(os.path.join(self.config['pack_dir'], file))):
 447                 self.zipfiles.append(ZipFile(os.path.join(self.config['pack_dir'], file)))
 448
 449         self.running = self.addFile(self.config['init'], '')
 450         self.app.init(self.main_container)
 451
 452         self.ticks = pygame.time.get_ticks()
 453         self.frames = 0
 454
 455         if self.running == 0:
 456             print "Engine.__init__(): Failed adding initial file"
 457
 458         self.message_boxen = []
 459
 460     def run(self):
 461
 462         global the_client
 463
 464         while self.running:
 465
 466             self.process_events()
 467
 468             self.draw()
 469
 470             pygame.display.flip()
 471
 472         return
 473
 474     def updateFPS(self):
 475
 476         self.oldticks = self.ticks
 477         self.ticks = pygame.time.get_ticks()
 478
 479         self.frames += 1
 480
 481         self.fps = (self.frames * 1000) / (self.ticks - self.oldticks) / 1000
 482
 483         pygame.display.set_caption(''.join([self.config['window_title'], ' ', str(self.fps)]))
 484
 485         return
 486
 487     def process_events(self):
 488
 489         change = 0
 490
 491         for e in pygame.event.get():
 492             if e.type == QUIT:
 493                 self.running = 0
 494                 print "Should be quitting..."
 495
 496                 self.killGame()
 497
 498             self.app.event((e))
 499             change = self.app.update(self.gui_screen.surf)
 500
 501             if (change != 0):
 502                 self.gui_screen.refresh(change)
 503
 504             new_event = self.convertEvent(e)
 505             self.events.addEvent(new_event)
 506
 507         iterating = 1
 508         while iterating:
 509
 510             if self.events.size():
 511                 new_event = self.events.getEvent()
 512             else:
 513                 iterating = 0
 514
 515             if not iterating:
 516                 return
 517
 518             if iterating:
 519                 for file in self.files.keys():
 520
 521                     for name in self.files[file]['object_instances'].keys():
 522
 523                         self.files[file]['object_instances'][name].event(new_event[0], new_event[1])
 524
 525         return
 526
 527     def convertEvent(self, e):
 528
 529         data = {}
 530
 531         if e.type == QUIT:
 532             data['none'] = ''
 533
 534         if e.type == ACTIVEEVENT:
 535             data['gain'] = e.gain
 536             data['state'] = e.state
 537
 538         if e.type == KEYDOWN:
 539             data['unicode'] = e.unicode
 540             data['key'] = e.key
 541             data['mod'] = e.mod
 542
 543         if e.type == KEYUP:
 544             data['key'] = e.key
 545             data['mod'] = e.mod
 546
 547         if e.type == MOUSEMOTION:
 548             data['pos'] = e.pos
 549             data['rel'] = e.rel
 550             data['buttons'] = e.buttons
 551
 552         if e.type == MOUSEBUTTONUP:
 553             data['pos'] = e.pos
 554             data['button'] = e.button
 555
 556         if e.type == MOUSEBUTTONDOWN:
 557             data['pos'] = e.pos
 558             data['button'] = e.button
 559
 560         if e.type == JOYAXISMOTION:
 561             data['joy'] = e.joy
 562             data['axis'] = e.axis
 563             data['value'] = e.value
 564
 565         if e.type == JOYBALLMOTION:
 566             data['joy'] = e.joy
 567             data['ball'] = e.ball
 568             data['rel'] = e.rel
 569
 570         if e.type == JOYHATMOTION:
 571             data['joy'] = e.joy
 572             data['hat'] = e.hat
 573             data['value'] = e.value
 574
 575         if e.type == JOYBUTTONUP:
 576             data['joy'] = e.joy
 577             data['button'] = e.button
 578
 579         if e.type == JOYBUTTONDOWN:
 580             data['joy'] = e.joy
 581             data['button'] = e.button
 582
 583         if e.type == VIDEORESIZE:
 584             data['size'] = e.size
 585             data['w'] = e.w
 586             data['h'] = e.h
 587
 588         if e.type == VIDEOEXPOSE:
 589             data['none'] = ''
 590
 591         if e.type == USEREVENT:
 592             data['code'] = e.code
 593
 594         type = ''
 595
 596         if e.type == QUIT: type = "QUIT"
 597         if e.type == ACTIVEEVENT: type = "ACTIVEEVENT"
 598         if e.type == KEYDOWN: type = "KEYDOWN"
 599         if e.type == KEYUP: type = "KEYUP"
 600         if e.type == MOUSEMOTION    : type = "MOUSEMOTION"
 601         if e.type == MOUSEBUTTONUP: type = "MOUSEBUTTONUP"
 602         if e.type == MOUSEBUTTONDOWN: type = "MOUSEBUTTONDOWN"
 603         if e.type == JOYAXISMOTION: type = "JOYAXISMOTION"
 604         if e.type == JOYBALLMOTION: type = "JOYBALLMOTION"
 605         if e.type == JOYHATMOTION: type = "JOYHATMOTION"
 606         if e.type == JOYBUTTONUP: type = "JOYBUTTONUP"
 607         if e.type == JOYBUTTONDOWN: type = "JOYBUTTONDOWN"
 608         if e.type == VIDEORESIZE: type = "VIDEORESIZE"
 609         if e.type == VIDEOEXPOSE: type = "VIDEOEXPOSE"
 610         if e.type == USEREVENT: type = "USEREVENT"
 611
 612         return [type, data]
 613
 614     def draw(self):
 615
 616         glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
 617         glLoadIdentity()
 618
 619         # draw stuff
 620
 621         glLoadIdentity()
 622         self.gui_screen.display()
 623
 624     def resize(self, (width, height)):
 625         if height==0:
 626             height=1
 627         glViewport(0, 0, width, height)
 628         glMatrixMode(GL_PROJECTION)
 629         glLoadIdentity()
 630         gluPerspective(45, 1.0*width/height, 0.1, 100.0)
 631         glMatrixMode(GL_MODELVIEW)
 632         glLoadIdentity()
 633
 634         return
 635
 636     def addFile(self, filename, parent):
 637
 638       # Because I have alot of nesting in this function,
 639       # I am using 2 space formatting
 640
 641       for zipfile in self.zipfiles:
 642
 643         for file in zipfile.namelist():
 644
 645           if (file == filename):
 646             dom = parseString(zipfile.read(file))
 647
 648             object_instances_d = []
 649             menu_instances = []
 650
 651             if dom.childNodes[0].nodeName == 'game':
 652               self.files[filename] = {
 653                   'object_defs': {},
 654                   'children': [],
 655                   'parent': '',
 656                   'object_instances': {},
 657                   'menu_instances': {},
 658                   'menu_defs': {}}
 659
 660               for node in dom.childNodes[0].childNodes:
 661
 662                 if (node.nodeName == 'def'):
 663
 664                   for sub_node in node.childNodes:
 665
 666                     if (sub_node.nodeName == 'object'):
 667
 668                       temp_object_def = {}
 669
 670                       for suber_node in sub_node.childNodes:
 671
 672                         if (suber_node.nodeName == 'name'):
 673                           if len(suber_node.childNodes):
 674                             temp_object_def['name'] = suber_node.childNodes[0].nodeValue
 675
 676                         if (suber_node.nodeName == 'script'):
 677                           if len(suber_node.childNodes):
 678                             temp_object_def['script'] = suber_node.childNodes[0].nodeValue
 679
 680                         if (suber_node.nodeName == 'tangible'):
 681                           if len(suber_node.childNodes):
 682                             temp_object_def['tangible'] = suber_node.childNodes[0].nodeValue
 683
 684                         if (suber_node.nodeName == 'type'):
 685                           if len(suber_node.childNodes):
 686                             temp_object_def['type'] = suber_node.childNodes[0].nodeValue
 687
 688                       self.files[filename]['object_defs'][temp_object_def['name']] = temp_object_def
 689                       temp_object_def = {}
 690
 691                     if (sub_node.nodeName == 'menu'):
 692
 693                       temp_menu_def = {}
 694                       temp_menu_def['elements'] = {}
 695
 696                       temp_element_set = {}
 697
 698                       for suber_node in sub_node.childNodes:
 699
 700                         if (suber_node.nodeName == 'name'):
 701                           temp_menu_def['name'] = suber_node.childNodes[0].nodeValue
 702
 703                         if (suber_node.nodeName == 'elements'):
 704
 705                           for suberer_node in suber_node.childNodes:
 706
 707                             if (suberer_node.nodeType != 3 and suberer_node.nodeType != 8):
 708                               if (suberer_node.hasAttribute('name')):
 709                                 temp_element_set['name'] = suberer_node.getAttribute('name')
 710
 711                               if (suberer_node.hasAttribute('x')):
 712                                 temp_element_set['x'] = int(suberer_node.getAttribute('x'))
 713
 714                               if (suberer_node.hasAttribute('y')):
 715                                 temp_element_set['y'] = int(suberer_node.getAttribute('y'))
 716
 717                               if (suberer_node.hasAttribute('width')):
 718                                 temp_element_set['width'] = int(suberer_node.getAttribute('width'))
 719
 720                               if (suberer_node.hasAttribute('height')):
 721                                 temp_element_set['height'] = int(suberer_node.getAttribute('height'))
 722
 723                               if (suberer_node.hasAttribute('parent')):
 724                                 temp_element_set['parent'] = suberer_node.getAttribute('parent')
 725
 726                               if (suberer_node.hasAttribute('target')):
 727                                 temp_element_set['target'] = suberer_node.getAttribute('target')
 728
 729                               if (suberer_node.hasAttribute('text')):
 730                                 temp_element_set['text'] = suberer_node.getAttribute('text')
 731
 732                               temp_element_set['type'] = suberer_node.nodeName
 733                               temp_menu_def['elements'][temp_element_set['name']] = temp_element_set
 734                               temp_element_set = {}
 735
 736                       self.files[filename]['menu_defs'][temp_menu_def['name']] = temp_menu_def
 737
 738                       temp_menu_def = {}
 739                       temp_element_set = {}
 740
 741                 if (node.nodeName == 'instance'):
 742
 743                   for sub_node in node.childNodes:
 744
 745                     if (sub_node.nodeName == 'object'):
 746                       object_instances_d.append(sub_node.childNodes[0].nodeValue)
 747
 748                     if (sub_node.nodeName == 'menu'):
 749                       menu_instances.append(sub_node.childNodes[0].nodeValue)
 750
 751             if (parent != ''):
 752               self.files[parent]['children'].append(filename)
 753             self.files[filename]['parent'] = parent
 754
 755             # create instances
 756
 757             for menuname, menu_data in self.files[filename]['menu_defs'].iteritems():
 758               self.files[filename]['menu_instances'][menuname] = Menu(menu_def=menu_data)
 759
 760             for menuname in menu_instances:
 761               if (self.files[filename]['menu_instances'].has_key(menuname)):
 762                 self.files[filename]['menu_instances'][menuname].show()
 763
 764               for file in self.files.keys():
 765                 if self.files[file]['menu_instances'].has_key(menuname):
 766                   self.files[file]['menu_instances'][menuname].show()
 767
 768             for objectname in object_instances_d:
 769               self.addObject(objectname)
 770
 771             return 1
 772       return 0
 773     # ending 2-space formatting
 774
 775     def removeFile(self, filename):
 776
 777         if (self.files.has_key(filename)):
 778
 779             for child in self.files[filename]['children']:
 780                 self.removeFile(child)
 781
 782             del self.files[filename]['children']
 783
 784             parent = self.files[filename]['parent']
 785             self.files[parent].pop(self.files[parent]['children'].index(filename))
 786
 787             del self.files[filename]
 788
 789         return
 790
 791     def getVisibleMenus(self):
 792
 793         menus = {}
 794
 795         for file, contents in self.files.iteritems():
 796             for name, menu in contents['menu_instances'].iteritems():
 797                 if not menu.hidden:
 798                     menus[name] = menu
 799
 800         return menus
 801
 802     def hideAllMenus(self):
 803
 804         for file, contents in self.files.iteritems():
 805             for name, menu in contents['menu_instances'].iteritems():
 806                 menu.hide()
 807
 808         return
 809
 810     def showMenu(self, menu_name):
 811
 812         for file, contents in self.files.iteritems():
 813             for name, menu in contents['menu_instances'].iteritems():
 814                 if contents['menu_instances'].has_key(menu_name):
 815                     contents['menu_instances'][menu_name].show()
 816
 817         return
 818
 819     def hideMenu(self, menu_name):
 820
 821         for file, contents in self.files:
 822             for name, menu in contents['menu_instances'].iteritems():
 823                 if contents['menu_instances'].has_key(menu_name):
 824                     contents['menu_instances'][menu_name].hide()
 825
 826         return
 827
 828     def setMenu(self, menu_name):
 829
 830         self.hideAllMenus()
 831         self.showMenu(menu_name)
 832
 833         return
 834
 835     def addObject(self, objectname):
 836
 837         for file in self.files.keys():
 838             if self.files[file]['object_defs'].has_key(objectname):
 839                 self.files[file]['object_instances'][objectname] = GameObject(
 840                     self.files[file]['object_defs'][objectname])
 841
 842         return
 843
 844     def removeObject(self, objectname):
 845
 846         for file in self.files.keys():
 847             if self.files[file]['object_defs'].has_key(objectname):
 848                 del self.files[file]['object_instances'][objectname]
 849
 850         return
 851
 852     def addListItem(self, menuname, item, data, dvalue):
 853
 854         for file in self.files:
 855             if self.files[file]['menu_instances'].has_key(menuname):
 856                 if self.files[file]['menu_instances'][menuname].widgets.has_key(item):
 857                     the_widget = self.files[file]['menu_instances'][menuname].widgets[item]
 858
 859                     the_widget.add(data.encode(), value=dvalue)
 860                     the_widget.resize()
 861                     the_widget.repaint()
 862
 863         return
 864
 865     def clearListItem(self, menuname, item):
 866
 867         for file in self.files:
 868             if self.files[file]['menu_instances'].has_key(menuname):
 869                 if self.files[file]['menu_instances'][menuname].widgets.has_key(item):
 870                     the_widget = self.files[file]['menu_instances'][menuname].widgets[item]
 871
 872                     the_widget.clear()
 873                     the_widget.resize()
 874                     the_widget.repaint()
 875
 876         return
 877
 878     def removeListItem(self, menuname, item, value):
 879
 880         for file in self.files:
 881             if self.files[file]['menu_instances'].has_key(menuname):
 882                 if self.files[file]['menu_instances'][menuname].widgets.has_key(item):
 883                     the_widget = self.files[file]['menu_instances'][menuname].widgets[item]
 884
 885                     the_widget.remove(value)
 886                     the_widget.resize()
 887                     the_widget.repaint()
 888
 889         return
 890
 891     def getListValue(self, menuname, item):
 892
 893         for file in self.files:
 894             if self.files[file]['menu_instances'].has_key(menuname):
 895
 896                 if self.files[file]['menu_instances'][menuname].widgets.has_key(item):
 897                     the_widget = self.files[file]['menu_instances'][menuname].widgets[item]
 898
 899                     return the_widget.value
 900
 901         return ''
 902
 903     def getEditboxValue(self, menuname, item):
 904
 905         for file in self.files:
 906             if self.files[file]['menu_instances'].has_key(menuname):
 907
 908                 if self.files[file]['menu_instances'][menuname].widgets.has_key(item):
 909                     the_widget = self.files[file]['menu_instances'][menuname].widgets[item]
 910
 911                     return the_widget.value
 912
 913         the_widget = self.files[file]['menu_instances'][menuname].widgets[item]
 914
 915         return the_widget.value
 916
 917     def setEditboxValue(self, menuname, item, new_value):
 918
 919         for file in self.files:
 920             if self.files[file]['menu_instances'].has_key(menuname):
 921
 922                 if self.files[file]['menu_instances'][menuname].widgets.has_key(item):
 923                     the_widget = self.files[file]['menu_instances'][menuname].widgets[item]
 924
 925                     the_widget.value = new_value
 926
 927                     return
 928
 929     def showMessageBox(self, message, title, width, height):
 930
 931         # Modify width and height to your liking
 932         width = 400
 933         height = 150
 934         the_engine.messageBox(title, message)
 935
 936         return
 937
 938     def getImage(self, filename):
 939
 940         the_buf = pygame.image.load(self.getStringIOFile(filename))
 941
 942         return the_buf
 943
 944     def getStringIOFile(self, filename):
 945
 946         for zip_file in self.zipfiles:
 947             for file in zip_file.namelist():
 948
 949                 if (filename == file):
 950
 951                     the_string_io = StringIO.StringIO()
 952                     print >>the_string_io, zip_file.read(file)
 953                     the_string_io.seek(0)
 954
 955                     return the_string_io
 956         return ''
 957
 958     def getStringData(self, filename):
 959         for zip_file in self.zipfiles:
 960             for file in zip_file.namelist():
 961
 962                 if (filename == file):
 963                     return zip_file.read(file)
 964         return ''
 965
 966     def killThreadGame(self):
 967
 968         reactor.stop()
 969
 970         return
 971
 972     def killGame(self):
 973
 974         reactor.callFromThread(self.killThreadGame)
 975
 976         return
 977
 978 class Menu:
 979
 980     def __init__(self, menu_def):
 981
 982         self.menu_def = menu_def
 983         self.widgets = {}
 984
 985         for name, element in menu_def['elements'].iteritems():
 986
 987             multiplier_x = float(the_engine.config['window_size'][0]) / 100.00
 988             multiplier_y = float(the_engine.config['window_size'][1]) / 100.00
 989
 990             dx = float(element['x']) * multiplier_x
 991             dy = float(element['y']) * multiplier_y
 992
 993             dwidth = float(element['width']) * multiplier_x
 994             dheight = float(element['height']) * multiplier_y
 995
 996             if (element['type'] == 'button'):
 997                 self.widgets[name] = pgui.Button(element['text'].encode(), width=dwidth, height=dheight)
 998                 self.widgets[name].connect(pgui.CLICK, self.clicked, name)
 999
1000             if (element['type'] == 'image'):
1001                 self.widgets[name] = pgui.Image(the_engine.getImage(element['text']))
1002
1003             if (element['type'] == 'label'):
1004                 self.widgets[name] = pgui.Label(element['text'])
1005
1006             if (element['type'] == 'listbox'):
1007                 self.widgets[name] = pgui.List(width=dwidth, height=dheight)
1008                 self.widgets[name].connect(pgui.CLICK, self.clicked, name)
1009
1010             if (element['type'] == 'editbox'):
1011                 self.widgets[name] = pgui.Input(value=element['text'], width=dwidth)
1012                 self.widgets[name].connect(pgui.KEYDOWN, self.key_pressed, name)
1013                 self.widgets[name].connect(pgui.KEYUP, self.key_up, name)
1014
1015             if (self.widgets.has_key(name)):
1016                 self.widgets[name].resize(width=dwidth, height=dheight)
1017             else:
1018                 print "Menu.__init__(): Widget type", element['type'], " not implemented yet, skipping."
1019
1020         self.hidden = 1
1021
1022     def show(self):
1023
1024         global the_engine
1025
1026         multiplier_x = float(the_engine.config['window_size'][0]) / 100.00
1027         multiplier_y = float(the_engine.config['window_size'][1]) / 100.00
1028
1029         if (self.hidden == 1):
1030             for name, element in self.menu_def['elements'].iteritems():
1031                 dx = float(element['x']) * multiplier_x
1032                 dy = float(element['y']) * multiplier_y
1033
1034                 if self.widgets.has_key(name):
1035                     the_engine.main_container.add(self.widgets[name], dx, dy)
1036
1037         self.hidden = 0
1038
1039         return
1040
1041     def hide(self):
1042
1043         global the_engine
1044
1045         if (self.hidden != 1):
1046             for name, element in self.menu_def['elements'].iteritems():
1047
1048                 if (self.widgets.has_key(name)):
1049                     the_engine.main_container.remove(self.widgets[name])
1050
1051         self.hidden = 1
1052
1053         return
1054
1055     def clicked(self, widget, _event):
1056
1057         if self.menu_def['elements'].has_key(widget):
1058
1059             if self.menu_def['elements'][widget]['target'] != '':
1060                 exec(self.menu_def['elements'][widget]['target'])
1061
1062             the_engine.events.addEvent(['WIDGET_CLICKED',
1063                                         {'name': widget,
1064                                          'menu_name': self.menu_def['name'],
1065                                          event: the_engine.convertEvent(_event)}])
1066
1067         return
1068
1069     def key_pressed(self, widget, _event):
1070
1071         if self.menu_def['elements'].has_key(widget):
1072
1073             new_event = the_engine.convertEvent(_event)
1074
1075             the_engine.events.addEvent(['KEYDOWN',
1076                                         {'name': widget,
1077                                          'menu_name': self.menu_def['name'],
1078                                          'event': new_event}])
1079
1080         return
1081
1082     def key_up(self, widget, _event):
1083
1084         if self.menu_def['elements'].has_key(widget):
1085
1086             the_engine.events.addEvent(['KEYUP',
1087                                         {'name': widget,
1088                                          'menu_name': self.menu_def['name'],
1089                                          event: the_engine.convertEvent(_event)}])
1090
1091         return
1092
1093 class MessageBox(pgui.Dialog):
1094
1095     def __init__(self, title, message):
1096
1097         self.title = pgui.Label(title)
1098         self.main = pgui.Label(message)
1099
1100         return
1101
1102 class GameObject:
1103
1104     def __init__(self, dmold):
1105
1106         self.mold = dmold
1107         global the_functions
1108         global in_script
1109
1110         if self.mold['script'] != '':
1111
1112             in_script = 1
1113
1114             the_file = the_engine.getStringData(self.mold['script'])
1115             if the_file != '':
1116                 exec(the_file)
1117
1118             in_script = 0
1119             self.my_functions = the_functions
1120
1121             the_functions = {}
1122
1123     def event(self, event, data):
1124
1125         if self.my_functions.has_key(event):
1126
1127             self.my_functions[event](data)
1128
1129         return
1130
1131 def main():
1132     # parse command line stuff
1133
1134     if (len(sys.argv) > 1):
1135         config = sys.argv[1]
1136     else:
1137         print "main(): No config specified, using", CONFIG
1138         config = CONFIG
1139
1140     configuration = parse_config(config)
1141
1142     if (configuration.has_key('error') and configuration['error']):
1143         print "main(): Error in parsing config."
1144
1145     the_event_receiver = EventReceiver()
1146
1147     global client_params
1148     client_params = {'broadcast_port':configuration['broadcast_port'],
1149                      'broadcast_bind':configuration['broadcast_bind'],
1150                      'message_port':configuration['message_port'],
1151                      'name':configuration['name'],
1152                      'echo_time': configuration['echo_time']}
1153
1154     global the_engine
1155     global the_client
1156
1157     the_engine = Engine(configuration)
1158
1159     the_client = Client()
1160     the_client_thread = threading.Thread(target=run_net)
1161
1162     the_client.server_request = 0
1163
1164     the_client.init(client_params)
1165
1166     the_client_thread.start()
1167     the_engine.run()
1168
1169     the_engine.killGame()
1170
1171     sys.exit()
1172
1173     the_client_thread.join()
1174
1175     return
1176
1177 def run_net():
1178
1179     global client_params
1180     global the_multicast
1181
1182     the_multicast = Multicast()
1183     config = client_params
1184
1185     reactor.listenMulticast(config['broadcast_bind'], the_multicast)
1186     reactor.listenUDP(config['message_port'], the_client)
1187
1188     echo_request = task.LoopingCall(the_client.serverRequest)
1189
1190     if client_params['echo_time'] != None:
1191         echo_request.start(client_params['echo_time'])
1192     else:
1193         print "run_net(): No ECHO_TIME specified, using default of", ECHO_TIME
1194         echo_request.start(ECHO_TIME)
1195
1196     reactor.run(installSignalHandlers=0)
1197
1198     return
1199
1200 def parse_config(filename):
1201     results = {'error': 1}
1202
1203     if (exists(filename)):
1204         dom = parse(filename)
1205     else:
1206         print "parse_config():", filename, "doesn't exist."
1207         return results
1208
1209     results = {'window_title': None,
1210                'log': None,
1211                'name': None,
1212                'font': None,
1213                'init': None,
1214                'message_port': None,
1215                'broadcast_port': None,
1216                'broadcast_bind': None,
1217                'fullscreen': None,
1218                'background_color': None,
1219                'window_size': None,
1220                'gravity': None,
1221                'step_size': None,
1222                'pack_dir': None,
1223                'echo_time': None}
1224
1225     if (dom.childNodes[0].nodeName == 'config'):
1226         for node in dom.childNodes[0].childNodes:
1227
1228             if (node.nodeName == 'window_title'):
1229                 results['window_title'] = node.childNodes[0].nodeValue
1230
1231             if (node.nodeName == 'log'):
1232                 results['log'] = node.childNodes[0].nodeValue
1233
1234             if (node.nodeName == 'name'):
1235                 results['name'] = node.childNodes[0].nodeValue
1236
1237             if (node.nodeName == 'font'):
1238                 results['font'] = node.childNodes[0].nodeValue
1239
1240             if (node.nodeName == 'init'):
1241                 results['init'] = node.childNodes[0].nodeValue
1242
1243             if (node.nodeName == 'message_port'):
1244                 results['message_port'] = int(node.childNodes[0].nodeValue)
1245
1246             if (node.nodeName == 'broadcast_port'):
1247                 results['broadcast_port'] = int(node.childNodes[0].nodeValue)
1248
1249             if (node.nodeName == 'broadcast_bind'):
1250                 results['broadcast_bind'] = int(node.childNodes[0].nodeValue)
1251
1252             if (node.nodeName == 'fullscreen'):
1253                 results['fullscreen'] = int(node.childNodes[0].nodeValue)
1254
1255             if (node.nodeName == 'background_color'):
1256
1257                 string_parts = node.childNodes[0].nodeValue.split()
1258                 results['background_color'] = [float(string_parts[0]), float(string_parts[1])]
1259                 results['background_color'].append(float(string_parts[2]))
1260                 results['background_color'].append(float(string_parts[3]))
1261
1262             if (node.nodeName == 'window_size'):
1263
1264                 string_parts = node.childNodes[0].nodeValue.split()
1265                 results['window_size'] = ((int(string_parts[0]), int(string_parts[1])))
1266
1267             if (node.nodeName == 'gravity'):
1268
1269                 string_parts = node.childNodes[0].nodeValue.split()
1270                 results['gravity'] = [float(string_parts[0]), float(string_parts[1])]
1271                 results['gravity'].append(float(string_parts[2]))
1272
1273             if (node.nodeName == 'step_size'):
1274                 results['step_size'] = float(node.childNodes[0].nodeValue)
1275
1276             if (node.nodeName == 'pack_dir'):
1277                 results['pack_dir'] = node.childNodes[0].nodeValue
1278
1279             if (node.nodeName == 'echo_time'):
1280                 results['echo_time'] = int(node.childNodes[0].nodeValue)
1281
1282     results['error'] = 0
1283
1284     return results
1285
1286 if __name__ == '__main__':
1287     main()