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