more_twisted.py

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