exploratio-0.1.1/0000755000175000017500000000000011311214451012334 5ustar renereneexploratio-0.1.1/run_game.py0000755000175000017500000000017511310754403014516 0ustar renerene#!/usr/bin/env python import sys #sys.path.insert(0, "lib") import lib.main if __name__ == "__main__": lib.main.main() exploratio-0.1.1/setup.py0000644000175000017500000001360011310751645014060 0ustar renerene# USAGE: python setup.py [command] Places results in 'dist' dir. # sdist - build a source dist py2exe - build an exe # py2app - build an app cx_freeze - build a linux binary APP_NAME = 'exploratio' VERSION = '0.1.1' DESCRIPTION = """Exploratio is a 48h ludumdare game""" cfg = { 'name':APP_NAME, 'version':VERSION, 'description':DESCRIPTION, 'author':'Rene Dudfield', 'author_email':'renesd@gmail.com', 'url':'', 'py2exe.target':'', #'py2exe.icon':'icon.ico', #64x64 'py2exe.binary':APP_NAME, #leave off the .exe, it will be added 'py2app.target':'', 'py2app.icon':'icon.icns', #128x128 #'cx_freeze.cmd':'~/src/cx_Freeze-3.0.3/FreezePython', 'cx_freeze.cmd':'cxfreeze', 'cx_freeze.target':'%s_linux' % APP_NAME, 'cx_freeze.binary':APP_NAME, } import os files_to_remove = ['tk84.dll', '_ssl.pyd', 'tcl84.dll', os.path.join('numpy','core', '_dotblas.pyd'), os.path.join('numpy', 'linalg', 'lapack_lite.pyd'), ] directories_to_remove = [os.path.join('numpy', 'distutils'), 'distutils', 'tcl', ] from distutils.core import setup, Extension try: import py2exe except: pass import sys import glob import os import shutil try: cmd = sys.argv[1] except IndexError: print 'Usage: setup.py py2exe|py2app|cx_freeze' raise SystemExit # utility for adding subdirectories def add_files(dest,generator): for dirpath, dirnames, filenames in generator: for name in 'CVS', '.svn': if name in dirnames: dirnames.remove(name) for name in filenames: if '~' in name: continue suffix = os.path.splitext(name)[1] if suffix in ('.pyc', '.pyo'): continue if name[0] == '.': continue filename = os.path.join(dirpath, name) dest.append(filename) # define what is our data data = [] add_files(data,os.walk('data')) data.extend(glob.glob('*.txt')) # define what is our source src = [] add_files(src,os.walk('lib')) src.extend(glob.glob('*.py')) # build the sdist target if cmd == 'sdist': f = open("MANIFEST.in","w") for l in data: f.write("include "+l+"\n") for l in src: f.write("include "+l+"\n") f.close() setup( name=cfg['name'], version=cfg['version'], description=cfg['description'], author=cfg['author'], author_email=cfg['author_email'], url=cfg['url'], ) # build the py2exe target if cmd in ('py2exe',): dist_dir = os.path.join('dist',cfg['py2exe.target']) data_dir = dist_dir src = 'run_game.py' dest = cfg['py2exe.binary']+'.py' shutil.copy(src,dest) setup( options={'py2exe':{ 'dist_dir':dist_dir, 'dll_excludes':['_dotblas.pyd','_numpy.pyd', 'numpy.linalg.lapack_lite.pyd', 'numpy.core._dotblas.pyd'] + files_to_remove, 'excludes':['matplotlib', 'tcl', 'OpenGL'], 'ignores':['matplotlib', 'tcl', 'OpenGL'], 'bundle_files':1, }}, # windows=[{ console=[{ 'script':dest, #'icon_resources':[(1,cfg['py2exe.icon'])], }], ) # build the py2app target if cmd == 'py2app': dist_dir = os.path.join('dist',cfg['py2app.target']+'.app') data_dir = os.path.join(dist_dir,'Contents','Resources') from setuptools import setup src = 'run_game.py' dest = cfg['py2app.target']+'.py' shutil.copy(src,dest) APP = [dest] DATA_FILES = [] OPTIONS = {'argv_emulation': True, 'iconfile':cfg['py2app.icon']} setup( app=APP, data_files=DATA_FILES, options={'py2app': OPTIONS}, setup_requires=['py2app'], ) # make the cx_freeze target if cmd == 'cx_freeze': app_dist_dir = cfg['cx_freeze.target'] + "_" + cfg['version'] dist_dir = os.path.join('dist', app_dist_dir) data_dir = dist_dir modules_exclude = "tcl,tk" cmd_args = (cfg['cx_freeze.cmd'], dist_dir, cfg['cx_freeze.binary'], modules_exclude) sys_cmd = '%s --install-dir=%s --target-name=%s --exclude-modules=%s run_game.py' % cmd_args print sys_cmd os.system(sys_cmd) import shutil if os.path.exists(os.path.join(data_dir, "tcl")): shutil.rmtree( os.path.join(data_dir, "tcl") ) if os.path.exists(os.path.join(data_dir, "tk")): shutil.rmtree( os.path.join(data_dir, "tk") ) # recursively make a bunch of folders def make_dirs(dname_): parts = list(os.path.split(dname_)) dname = None while len(parts): if dname == None: dname = parts.pop(0) else: dname = os.path.join(dname,parts.pop(0)) if not os.path.isdir(dname): os.mkdir(dname) # copy data into the binaries if cmd in ('py2exe','cx_freeze','py2app'): dest = data_dir for fname in data: dname = os.path.join(dest,os.path.dirname(fname)) make_dirs(dname) if not os.path.isdir(fname): #print (fname,dname) shutil.copy(fname,dname) # make a tgz files. if cmd == 'cx_freeze': sys_cmd = "cd dist; tar -vczf %s.tgz %s/" % (app_dist_dir,app_dist_dir) os.system(sys_cmd) # remove files from the zip. if 0 and cmd in ('py2exe'): import shutil #shutil.rmtree( os.path.join('dist') ) #shutil.rmtree( os.path.join('build') ) os.system("unzip dist/library.zip -d dist\library") for fn in files_to_remove: os.remove( os.path.join('dist', 'library', fn) ) for d in directories_to_remove: if os.path.exists( os.path.join('dist', 'library', d) ): shutil.rmtree( os.path.join('dist', 'library', d) ) os.remove( os.path.join('dist', 'library.zip') ) os.chdir("dist") os.chdir("library") os.system("zip -r -9 ..\library.zip .") os.chdir("..") os.chdir("..") exploratio-0.1.1/lib/0000755000175000017500000000000011311214451013102 5ustar renereneexploratio-0.1.1/lib/__init__.py0000644000175000017500000000000011310704062015202 0ustar renereneexploratio-0.1.1/lib/rdpyg/0000755000175000017500000000000011311214451014227 5ustar renereneexploratio-0.1.1/lib/rdpyg/__init__.py0000644000175000017500000000000011143032614016330 0ustar renereneexploratio-0.1.1/lib/rdpyg/util/0000755000175000017500000000000011311214451015204 5ustar renereneexploratio-0.1.1/lib/rdpyg/util/__init__.py0000644000175000017500000000000011143032614017305 0ustar renereneexploratio-0.1.1/lib/rdpyg/util/cyclic_list.py0000644000175000017500000000225511143032614020065 0ustar renerene# file: cycling list. # purpose: a pointer to the current item is needed. # A goto_next method is needed. Which cycles over the next idx. import UserList class cyclic_list(UserList.UserList): def __init__(self, *args, **kwargs): UserList.UserList.__init__(self, *args, **kwargs) self.idx = 0 def next(self): """ increments the cursor, and returns the new current idx. """ self.idx += 1 if self.idx >= len(self.data): self.idx = 0 return self.idx def prev(self): """ decrements the cursor, and returns the new current idx. """ self.idx -= 1 if self.idx < 0: self.idx = len(self.data) -1 return self.idx def cur(self): """ returns the element at the current cursor. """ return self.data[self.idx] def set_cur(self, idx): """ Sets the current cursor to the given idx. """ self.idx = idx if __name__ == "__main__": c = cyclic_list([1,2,3,4]) print c.idx c.next() print c.idx c.next() print c.idx c.next() print c.idx c.next() print c.idx for x in range(5): c.prev() print c.idx exploratio-0.1.1/lib/rdpyg/util/paths.py0000644000175000017500000003224211143032614016702 0ustar renerene#file: paths.py #purpose: for 3d objects to follow paths. # NOTE: follows the opengl coordinate system. # distance units are in meters # time units are in seconds. import math # these are the types of loop the path can follow. LOOP_TYPES = ["stop", "loop", "backwards"] class Path: """ Used for storing the path from one point to another. For working out where an object following that path at a certain speed would be. p = Path() p.SetPoints([[0., 0., 0.], [0., 1., 0.], [1., 1., 0.], [2., 2., 0.], [3., 3., 0.]]) This creates a path of straight lines. Now whatever is traveling along the path can use: point_along_path = p.Travel(speed=0.5, elapsed_time=5) Which will travel along the path 0.5 * 5 units, and give you the point where it is up to. """ def __init__(self, points = [], loop_type = "stop"): """ points - defaults to []. should be like [[0.,0.,0.],[0.,1.,0.]] """ self.elapsed_time = 0. self.SetPoints(points) self.SetLoopType(loop_type) def SetLoopType(self, loop_type): """ SetLoopType("stop") -> None Can be set to one of LOOP_TYPES, ["stop", "loop", "backwards"] """ if loop_type in LOOP_TYPES: self.loop_type = loop_type else: raise NotImplementedError, loop_type def length(self): """ length() -> length of the path. TODO: why isn't this __len__() ? """ return length_line(self.points) def SetPoints(self, point_list): """ SetPoints(point_list) -> None Sets the points along the path. point_list - eg [[1., 1., 1.], [2., 2., 2.]] With each sublist being a point (x,y,z) in 3d space. """ #TODO: should we make the points a tuple? # this would allow the path to be used as a hash value. if len(point_list) == 0: point_list = [[0.,0.,0.], [0.,0.,0.]] if len(point_list) == 1: point_list = [point_list[0], point_list[0]] self.points = point_list if len(self.points) > 1: # we start at the beginning. self.current_point = self.points[0] # Where we are going to. self.current_heading_to_idx = 1 self.current_idx = 0 def SetNewPoint(self, point): """ SetNewPoint([x,y,z]) -> None Sets the current point that the traveller is on. """ self.current_point = point def GotoNextLine(self): """ GotoNextLine() -> None Starts heading to the next line in path. """ # what happens if we get to the end? self.current_heading_to_idx += 1 self.current_idx = self.current_heading_to_idx - 1 if len(self.points) == self.current_heading_to_idx: if self.loop_type == "stop": pass elif self.loop_type == "loop": self.current_heading_to_idx = 0 elif self.loop_type == "backwards": self.points.reverse() self.current_heading_to_idx = 1 self.current_idx = 0 def ShouldStop(self): """ ShouldStop() -> Bool Are we at the end and is the loop_type "stop" """ if self.loop_type == "stop": if self.current_idx >= len(self.points) -1: return 1 else: return 0 else: return 0 def Where(self): """ Where() -> position. Returns the current position of the traveler. """ return self.current_point[:] def GetHeadingToPoint(self): """ GetHeadingToPoint() -> position Returns the point which the traveler is heading to. """ return self.points[self.current_heading_to_idx] def __str__(self): return str(self.points) def __eq__(self, other): #print self.points == other.points #print self.elapsed_time == other.elapsed_time #print self.loop_type == other.loop_type #print self.current_point == other.current_point #print self.current_heading_to_idx == other.current_heading_to_idx #print self.current_idx == other.current_idx if not other.__class__ == self.__class__: return 0 if ((self.points == other.points) and (self.elapsed_time == other.elapsed_time) and (self.loop_type == other.loop_type) and (self.current_point == other.current_point) and (self.current_heading_to_idx == other.current_heading_to_idx) and (self.current_idx == other.current_idx)): return 1 else: return 0 def __ne__(self, other): return not self.__eq__(other) def GetBackwardsPoint(self, distance): """ GetBackwardsPoint(distance) -> position Returns a point backwards from the current direction along the path. distance - backwards along the path. """ #FIXME: I think this may be broken for the case where the traveler # is not moving. cur_point = self.Where() if self.ShouldStop(): #print self.current_heading_to_idx, "current_heading_to_idx" next_point = cur_point cur_point= self.points[0] else: next_point = self.points[self.current_heading_to_idx] backwards_point = backwards(cur_point, next_point, distance) return backwards_point def Travel(self, speed, elapsed_time): """ Travel(float, float) -> position Returns the point along the path that the traveler is at. speed - units per second. Average since the last call to this. elapsed_time - since the last call to this. """ if self.ShouldStop(): return self.Where() end_point = self.points[self.current_heading_to_idx] start_point = self.Where() time_left, new_point = travel_line(start_point, end_point, speed, elapsed_time) self.SetNewPoint(new_point) # to prevent an infinite loop incase this code is buggy. MAXIMUM_ITERATIONS = 100 c = 0 while not within(time_left, 0.0, 0.00001): # there is some time left. elapsed_time = time_left self.GotoNextLine() if self.ShouldStop(): break start_point = self.Where() end_point = self.points[self.current_heading_to_idx] time_left, new_point = travel_line(start_point, end_point, speed, elapsed_time) self.SetNewPoint(new_point) c += 1 # a sanity check to avoid maybe possible infinite loops. if c >= MAXIMUM_ITERATIONS: raise RuntimeError("too many iterations trying to find new place on path") return new_point # Some support for paths which can be copied with twisted. # TODO: remove this?? try: import config if config.USE_TWISTED: from twisted.spread import pb class CopyPath(Path, pb.Copyable, pb.RemoteCopy): pass pb.setUnjellyableForClass('paths.CopyPath', CopyPath) except: pass # Some helper functions. def within(a,b, error_range): """ within(num, num, num) -> bool check if a is with error_range of b. """ return abs(a - b) < error_range def travel_line(start_point, end_point, speed, elapsed_time): """ travel_lines(point, point, num, num) -> (time_left, new_point) Travels along the line given at a given speed, for a given time. """ distance = speed * elapsed_time distance_to_end = distance_between_points(start_point, end_point) reached_end = 0 if within(distance, distance_to_end, 0.00000001): # right on the end. return (0.0, end_point) elif within(distance_to_end, 0.0, 0.00000001): return (elapsed_time, end_point) elif distance > distance_to_end: reached_end = 1 if reached_end: # we have reached the end, so we figure out how much time we have left. # The new_point is the end_point ##t=elapsed_time-(elapsed_time-((distance - distance_to_end) / speed)) #time_left = elapsed_time - (elapsed_time / distance) t = elapsed_time-(elapsed_time-((distance - distance_to_end) / speed)) time_left = t return (time_left, end_point) else: # need to figure out where we are on the line between start and end. ratio = distance / distance_to_end if within(ratio, 1.0, 0.00000001): return (0.0, end_point) else: time_left = 0.0 new_point = interpolate_line(start_point, end_point, ratio) return (time_left, new_point) def interpolate_line(start_point, end_point, t): """ interpolate_line(point, point, num) -> point returns the new point along the line given. start_point - of the line. end_point - of the line. t - ratio between 0. - 1. along the line. """ # numeric: # (e - s) * t # other formula. probably faster if I make a line class, # or cache results in some other way. # # sx,sy = start # ex,ey = end # stepx = (ex-sx) / total_length # stepy = (ey-sy) / total_length # midx = sx + stepx * length # midy = sy + stepy * length # # another formular: # # (1 - t)*s + t * e #assert( t <= 1.0 ) if len(start_point) == 3: one_minus_t = 1 -t x = (start_point[0] * one_minus_t) + (end_point[0] * t) y = (start_point[1] * one_minus_t) + (end_point[1] * t) z = (start_point[2] * one_minus_t) + (end_point[2] * t) return [x,y,z] elif len(start_point) == 2: one_minus_t = 1 -t x = (start_point[0] * one_minus_t) + (end_point[0] * t) y = (start_point[1] * one_minus_t) + (end_point[1] * t) return [x,y] else: raise NotImplementedError def length_line(points): """ length([point]) -> num returns the length of the line represented by the points. """ len_points = len(points) if len_points < 1: return 0. elif len_points == 2: return distance_between_points(points[0], points[1]) else: total_length = 0 last_point = points[0] # go through all but the first point. for point in points[1:]: total_length += distance_between_points(last_point, point) last_point = point return total_length def distance_between_points(p1, p2): """ distance_between_points(point, point) -> num Returns the distance between two points. """ if len(p1) == 3: return math.sqrt( (p1[0] - p2[0])**2 + (p1[1] - p2[1])**2 + (p1[2] - p2[2])**2 ) elif len(p1) == 2: return math.sqrt( (p1[0] - p2[0])**2 + (p1[1] - p2[1])**2 ) else: raise NotImplementedError def backwards(cur_point, next_point, distance): """ backwards(point, point, num) -> point Returns the point backwards along the given line. """ # Find the distance between the current and next point. distance_to_next = distance_between_points(cur_point, next_point) # normalise that value to 1.0 normalised_distance = 1. / distance_to_next # multiply the distance wanted to travel by the normalised value. interpolated_num = distance * normalised_distance backwards_point = interpolate_line(cur_point, next_point, -interpolated_num) return backwards_point def forwards(cur_point, next_point, distance): """ forwards(point, point, num) -> point Returns the point forwards the distance along the given line. From the current point! """ # Find the distance between the current and next point. distance_to_next = distance_between_points(cur_point, next_point) # normalise that value to 1.0 normalised_distance = 1. / distance_to_next # multiply the distance wanted to travel by the normalised value. interpolated_num = distance * normalised_distance forwards_point = interpolate_line(cur_point, next_point, interpolated_num) return forwards_point def forwards_from_next(cur_point, next_point, distance): """ forwards(point, point, num) -> point Returns the point forwards the distance along the given line. From the next point! """ forwards_point = interpolate_line(cur_point, next_point, 1.2) cur_point = next_point next_point = forwards_point # Find the distance between the current and next point. distance_to_next = distance_between_points(cur_point, next_point) # normalise that value to 1.0 normalised_distance = 1. / distance_to_next # multiply the distance wanted to travel by the normalised value. interpolated_num = distance * normalised_distance forwards_point = interpolate_line(cur_point, next_point, interpolated_num) return forwards_point def point_within(point, a_rect): """ point_within([x,y], rectstyle) -> true if a point is within the rect. """ x,y,w,h = a_rect px, py = point[:2] if px < x: return 0 if px > x + w: return 0 if py < y: return 0 if py > y + h: return 0 return 1 exploratio-0.1.1/lib/rdpyg/util/pack_textures.py0000644000175000017500000002074011143032614020444 0ustar renerene""" TODO: need to return UV coordinates and pixel coordinates for the packing/cutting functions for where the images are located on the textures. Code to pack multiple textures into larger ones. As well as to cut up bigger textures into smaller ones. This is useful for eg opengl where there are textures size limits. Also it can speed up rendering as you need to do less texture binding calls, and you can reduce geometry calls too. Power of 2 textures can be a waste of memory if you have non power of 2 sized images. The more video memory saved the faster a game can go. To make this code more useful it will work with rectangles. So that it can be used to update texture memory as well as to update images. There will also need to be possibly multiple big output textures. So that you can specify a maximum size output texture. """ #import psyco #psyco.full() class Texture: """ One texture which holds multiple smaller ones packed in. x,y bottom left is 0,0. Which is like opengl, and not like sdl. """ def __init__(self, x,y, height,width): self.x = x self.y = y self.height = height self.width = width self.sub_textures= [] def __repr__(self): return "<%s,%s,%s,%s>" % (self.x, self.y, self.height, self.width) def try_fit(self, other_texture): """ Tries to fit the texture into itself. Returns true if successful. """ if not self.could_fit(other_texture): return False # an early in. if there are no other textures, then just put it in. if(self.sub_textures == []): self.sub_textures.append(other_texture) return True # Do a search for a place to put it. return self.search_for_fit(other_texture) def try_fit_batch(self, other_textures): """ Tries to fit the textures into itself. Returns true if successful???. Or returns the unfitted ones? """ # see if they are the same size. same_size = 0 o=other_textures[0] x,y,height,width = o.x, o.y, o.height, o.width r = filter(lambda oo:(oo.height == height and oo.width == width), other_textures) if len(r) == len(other_textures): same_size = 1 # If they are all the same size, and the texture is empty we # can optimize it. unfitted = [] if same_size and self.sub_textures == []: # See how many in a row we could fit along the x. # then raise along the y. number_on_x = int(round(self.width / width)) number_on_y = int(round(self.height / height)) x_pos = 0 y_pos = 0 for o in other_textures: if(y_pos > number_on_y): # not anymore room. unfitted.append(o) else: o.x = x_pos * width o.y = y_pos * height self.sub_textures.append(o) x_pos += 1 if(x_pos > number_on_x): y_pos += 1 x_pos = 0 else: # TODO: sort the textures into batches of the same size. # could be able to be fairly fast then. # try fitting them one at a time. for other_texture in other_textures: r = self.try_fit(other_texture) if not r: unfitted.append(other_texture) return unfitted def collide(self, other_texture): """ checks this texture only to see if it collides. Returns True if it does collide. """ sx = self.x sy = self.y ox = other_texture.x oy = other_texture.y s_right = sx + self.width s_top = sy + self.height o_right = ox + other_texture.width o_top = oy + other_texture.height # check that it is not within the x or y. if(ox >= s_right): return False if(o_right < sx): return False if(o_top <= sy): return False if(oy > s_top): return False return True def could_fit(self, other_texture): """ checks this texture only to see if it fits. Does not care about any textures inside. """ # some early outs. if(other_texture.height > self.height): return False if(other_texture.width > self.width): return False if(other_texture.x != 0 or other_texture.y != 0 or self.x != 0 or self.y != 0): # if the x,y is not zero then need to adjust for that. s_right = self.x + self.width s_top = self.y + self.height o_right = other_texture.x + other_texture.width o_top = other_texture.y + other_texture.height if(o_top > s_top or o_right > s_right or other_texture.x < self.x or other_texture.y < self.y): return False return True def search_for_fit(self, o): """ do a search for a place to put the texture, and place it. Return True if successful, else false. o - other texture. """ #TODO: try and optimize this. #return self._brute_force(o) return self._bottom_left_first(o) def _brute_force(self, o): """ do a brute force search from bottom left to top right. Return True if successful, else false. o - other texture. """ x_try = self.x y_try = self.y x_end = self.x + self.width y_end = self.y + self.height # go from x_try -> x_end seeing if it fits, # then increment y_try and go again. hits = 0 for y in range(y_try, y_end): for x in range(x_try, x_end): o.x = x o.y = y hits = 0 for sub in self.sub_textures: # if we can fit inside a sub texture, # then we need to keep looking. if sub.collide(o): hits = 1 break if not hits: break if not hits: break if not hits: self.sub_textures.append(o) return True else: return False def _bottom_left_first(self, o): """ do a search from bottom left. Return True if successful, else false. o - other texture. """ x_try = self.x y_try = self.y x_end = self.x + self.width y_end = self.y + self.height # go from x_try -> x_end seeing if it fits, # then increment y_try and go again. hits = 0 for y in range(y_try, y_end): x = x_try while x < x_end: #for x in range(x_try, x_end): o.x = x o.y = y hits = 0 for sub in self.sub_textures: # if we can fit inside a sub texture, # then we need to keep looking. if sub.collide(o): hits = 1 # move accross to the x of the sub. x = sub.x + sub.width break if not hits: break x += 1 if not hits: break if not hits: self.sub_textures.append(o) return True else: return False def clear(self): """ clears all the textures in this one. """ self.sub_textures= [] def pack_images_into_multiple(small_list, max_size, use_pow2 = 1): """ returns a list of Texture objects with the textures from the small_list packed into them. small_list - list of Texture objects max_size - of the output Textures. use_pow2 - if 0 then we do not have to limit ourselves to power of 2. """ raise NotImplementedError def split_big_image(big_image, max_size, use_pow2 = 1): """ returns a list of Textures which the big_image is split into. big_image - a Texture object. TODO: how to determine where the small bits are placed? """ raise NotImplementedError exploratio-0.1.1/lib/rdpyg/util/vtimer.py0000644000175000017500000000711111143032614017066 0ustar renerene# file: virtual_timer.py # purpose: to be able to do things once a time is up. # or to keep track of something which lasts a given time. class vtimer: """ times something. when it is done it is equal to 1, else equal to 0. Useage: v = VirtTimer(5.) if v: dosomething() v.Update(elapsed_time) OR with a callback. v = VirtTimer(5., dosomething) v.Update(elapsed_time) Call Update on each game tick. Passing in elapsed time in seconds allows you to have timers running on different time. So pausing, and things like bullet time are easy. Also has some other features. You can be notified on the "edge" of time. That is when a timer is just_started or just_finished. if v.just_finished: do_some_other_thing() You can find how much time is left. As well as get a normalised amount of time left(between 0. and 1.). eg. time_before_powerup_runs_out = powerup_timer.left() """ def __init__(self, length, callback = None): """ length - of time to run for. callback - optional callback function to call. """ self.length = length self.callback = callback self.reset() self.update = self.Update self.is_not_used = 0 def Update(self, elapsed_time): """Update(1.0) -> None To be called on every game tic. elapsed_time - since last update. """ if self.just_started: self.just_started = 0 if self.just_finished: self.just_finished = 0 self.total_elapsed_time += elapsed_time if self.total_elapsed_time >= self.length: if self.done == 0: self.just_finished = 1 self.done = 1 if self.callback != None: if not self.called_callback: self.callback() self.called_callback = 1 def reset(self): """ reset() -> None Resets the timer to the beginning. """ self.total_elapsed_time = 0. self.done = 0 self.called_callback = 0 self.just_started = 1 self.just_finished = 0 self.is_not_used = 0 def set_finished_no_callback(self): """ set_finished_no_callback() -> None Sets it to finished, without calling callback. not just finished. """ self.total_elapsed_time = 10000000000000L self.done = 1 self.called_callback = 1 self.just_started = 0 self.just_finished = 0 self.is_not_used = 1 def not_used(self): """ not_used -> None For if the timer is not being used. This is useful for one time, timers. """ self.is_not_used = 1 # equality methods used for testing the timer. def __eq__(self, other): return self.done == other def __ne__(self, other): return not self.__eq__(other) def __nonzero__(self): return self.done def left(self): """ left() -> time left until finished. """ left = self.length - self.total_elapsed_time if left < 0.: return 0. else: return left def left_normalised(self): """ left_normalised() -> the time left normalized to 0. - 1. """ left = self.left() if left == 0.: return 0. else: return (1. / self.length) * left exploratio-0.1.1/lib/rdpyg/util/quaternion.py0000644000175000017500000002671311143032614017756 0ustar renerene"""Simple module providing a quaternion class for manipulating rotations easily. NOTE: unittest in quaternion_test.py NOTE: a lot of this code is taken from various places, including OpenglContext. Note: all angles are assumed to be specified in radians. Note: this is an entirely separate implementation from the PyOpenGL quaternion class. This implementation assumes that Numeric python will be available, and provides only those methods and helpers commonly needed for manipulating rotations. TODO: Make all functions use an array instead of a quat class. Make a quat class which uses the functions. Make a c version of for the python functions. - based off amd lib, gamasutra article, and CS quats. """ import Numeric, Matrix import math N = Numeric # some common math ones. pi = math.pi cos = math.cos acos = math.acos sin= math.sin atan= math.atan sqrt= math.sqrt def magnitude_vectors( vectors ): """Calculate the magnitudes of the given vectors vectors -- sequence object with 1 or more 3-item vector values. returns a double array with x elements, where x is the number of 3-element vectors """ vectors = N.asarray( vectors,'d', savespace = 1) vectors = N.reshape( vectors, (-1,3)) vectors = vectors*vectors result = vectors[:,0] N.add( result, vectors[:,1], result ) N.add( result, vectors[:,2], result ) N.sqrt( result, result ) return result def normalise_vectors( vectors ): """Get normalised versions of the vectors. vectors -- sequence object with 1 or more 3-item vector values. returns a double array with x 3-element vectors, where x is the number of 3-element vectors in "vectors" Will raise ZeroDivisionError if there are 0-magnitude vectors in the set. """ vectors = N.asarray( vectors, 'd', savespace = 1) vectors = N.reshape( vectors, (-1,3)) mags = N.reshape( magnitude_vectors( vectors ), (-1, 1)) return N.divide_safe( vectors, mags) def normalise_vector( vector ): """Given a 3 or 4-item vector, return a 3-item unit vector""" """ x,y,z = vector sqlen = x * x + y * y + z * z if (sqlen < SMALL_EPSILON): return vector invlen = sqrt (sqlen) return vector * invlen """ return normalise_vectors( vector[:3] )[0] def length_quat(quat): """ """ #w,x,y,z = quat.internal #length = x**2 + y**2 + z**2 + w**2 #return length return N.sum(quat.internal ** 2) def slerp_quat(quat_a, quat_b, slerp): """ Returns a quaternion spherically interpolated between quat_a, quat_b. quat_a, quat_b - quaternions to interpolate between. slerp - interp factor (0.0 = quat_a, 1.0 = quat_b) """ # TODO: FIXME: This is wrong! #raise NotImplementedError("broken implementation") # Difference at which to lerp instead of slerp DELTA = 0.0001 HALF_PI = math.pi /2 # DOT the quats to get the cosine of the angle between them cosom = N.sum(quat_a.internal * quat_b.internal) result = [0., 0., 0.,0.] # Two special cases: # Quats are exactly opposite, within DELTA? if (cosom > DELTA - 1.0): # make sure they are different enough to avoid a divide by 0 if (cosom < 1.0 - DELTA): # SLERP away omega = math.acos(cosom); isinom = 1.0 / math.sin(omega); scale0 = math.sin( (1.0 - slerp)*omega ) * isinom; scale1 = math.sin(slerp * omega) * isinom; else: # LERP is good enough at this distance scale0 = 1.0 - slerp; scale1 = slerp; result[0] = scale0 * quat_a.internal[0] + scale1 * quat_b.internal[0]; result[1] = scale0 * quat_a.internal[1] + scale1 * quat_b.internal[1]; result[2] = scale0 * quat_a.internal[2] + scale1 * quat_b.internal[2]; result[3] = scale0 * quat_a.internal[3] + scale1 * quat_b.internal[3]; else: # SLERP towards a perpendicular quat # Set slerp parameters #scale0 = math.sin ((1.0 - slerp) * HALF_PI); #scale1 = math.sin (slerp * HALF_PI); #q2w, q2x, q2y, q2z = quat_b.internal * N.array([-0.5,0.5,-0.5,0.5]) #result[0] = -quat_b.internal[1]; #result[1] = quat_b.internal[0]; #result[2] = -quat_b.internal[3]; #result[3] = quat_b.internal[2]; scale0 = sin((1.0 - slerp) * HALF_PI); scale1 = sin(slerp * HALF_PI); result[0] = scale0 * quat_a.internal[0] + scale1 * quat_b.internal[0]; result[1] = scale0 * quat_a.internal[1] + scale1 * quat_b.internal[1]; result[2] = scale0 * quat_a.internal[2] + scale1 * quat_b.internal[2]; result[3] = scale0 * quat_a.internal[3] + scale1 * quat_b.internal[3]; # Compute the result return Quaternion( result ) def get_angles_from_two_points(a,b): """ returns the angles along the x,y,z axis. this is direction of the two points. """ p1,p2 = N.array(a), N.array(b) origin = N.array([0.,0.,0.]) p2 = (origin - p1) + p2 p1 = origin v = N.absolute(p2 - p1) x,y,z = p2 if x >=0 and y >= 0: to_add = -180 elif x >= 0 and y < 0: to_add = 0 elif x < 0 and y >= 0: to_add = 180 elif x < 0 and y < 0: to_add = -360 else: # shouldn't get here. raise ValueError("shouldn't get here x:%s: y :%s: " % (x,y) ) #v = p2 - p1 # atan(Vy/Vx) if v[0] == 0: x_angle = 0. else: x_angle = atan(v[1] / v[0]) # atan(Vx/Vz) if v[1] == 0: y_angle = 0. else: y_angle = atan(v[0] / v[1]) # atan(Vy/Vx) if v[2] == 0: z_angle = 0. else: z_angle = atan(v[0] / v[2]) angles = map(radians_to_angle, (x_angle, y_angle, z_angle) ) new_angles = map(lambda x, y=to_add: x + y, angles) return map(abs, new_angles) #return (x_angle, y_angle, z_angle) def euler_to_quats(rotations): """ Returns a sequence of quats. It is an array where each quat is four floats. w,x,y,z is the order. rotations- an array of rotations. where each rotation is three floats. """ tmp = map(from_euler_list, rotations) return map(lambda x:x.internal, tmp) def fromMatrix(matrix): """ from a 4x4 matrix return a quaternion. These are the orders of the matrix: [00,01,02,03] [10,11,12,13] [20,21,22,23] [30,31,32,33] [0 , 1, 2, 3] [4 , 5, 6, 7] [8 , 9,10,11] [12,13,14,15] Which is the opengl order. """ m = matrix trace = matrix[0][0]+matrix[1][1]+matrix[2][2] s = sqrt (trace + 1.0); quat_s = (s * 0.5); s = 0.5 / s; q = Quaternion( [quat_s, (m[1][2]-m[2][1])*s, (m[2][0]-m[0][2])*s, (m[0][1]-m[1][0])*s ] ) return q def angle_to_radians(angle): pi_div_180 = pi / 180. return pi_div_180 * (angle % 360.) def radians_to_angle(radians): if radians == 0: return 0. return (180. / (pi / radians)) % 360. def fromAXYZ(a,x,y,z): return fromXYZR(x,y,z,angle_to_radians(a)) def fromXYZR( x,y,z, r ): """Create a new quaternion from a VRML-style rotation x,y,z are the axis of rotation r is the rotation in radians.""" x,y,z = normalise_vector( (x,y,z) ) return Quaternion ( N.array( [ cos(r/2.0), x*(sin(r/2.0)), y*(sin(r/2.0)), z*(sin(r/2.0)), ]) ) def from_euler_list( l ): return apply(fromEuler, l) def fromEuler_angle(x=0, y=0, z=0): """ From x,y,z angles in degrees create a quat. """ radians = map(angle_to_radians, (x,y,z)) return fromEuler(*radians) def fromEuler( x=0,y=0,z=0 ): """Create a new quaternion from a 3-element euler-angle rotation about x, then y, then z """ if x: base = fromXYZR( 1,0,0,x) if y: base = base * fromXYZR( 0,1,0,y) if z: base = base * fromXYZR( 0,0,1,z) return base elif y: base = fromXYZR( 0,1,0,y) if z: base = base * fromXYZR( 0,0,1,z) return base else: return fromXYZR( 0,0,1,z) class Quaternion: """Quaternion object implementing those methods required to be useful for OpenGL rendering (and not many others)""" def __init__ (self, elements = [1,0,0,0] ): """The initializer is a four-element array, w, x,y,z -- all elements should be doubles/floats the default values are those for a unit multiplication quaternion. """ elements = N.asarray( elements, 'd') length = sqrt( N.sum( elements * elements)) if length != 1: # print 'fixing quaternion length', repr(length) elements = elements/length self.internal = elements self.cache = {} def __mul__( self, other ): """Multiply this quaternion by another quaternion, generating a new quaternion which is the combination of the rotations represented by the two source quaternions. Other is interpreted as taking place within the coordinate space defined by this quaternion. Alternately, if "other" is a matrix, return the dot-product of that matrix with our matrix (i.e. rotate the coordinate) """ if hasattr( other, 'internal' ): w1,x1,y1,z1 = self.internal w2,x2,y2,z2 = other.internal w = w1*w2 - x1*x2 - y1*y2 - z1*z2 x = w1*x2 + x1*w2 + y1*z2 - z1*y2 y = w1*y2 + y1*w2 + z1*x2 - x1*z2 z = w1*z2 + z1*w2 + x1*y2 - y1*x2 return Quaternion( N.array([w,x,y,z],'d')) else: return N.dot( self.matrix (), other ) def AXYZ(self): """ returns the angle, and x,y,z as a vector. as used by glRotate. """ x,y,z,r = self.XYZR() return [radians_to_angle(r), x,y,z] def XYZR( self ): """Get a VRML-style axis plus rotation form of the rotation. Note that this is in radians, not degrees, and that the angle is the last, not the first item... (x,y,z,radians) """ w,x,y,z = self.internal try: aw = acos(w) except ValueError: # catches errors where w == 1.00000000002 aw = 0 scale = sin(aw) if not scale: return (0,1,0,0) return (x / scale, y / scale, z / scale, 2 * aw ) def matrix( self ): """Get a rotation matrix representing this rotation""" # TODO: should cache this. w,x,y,z = self.internal return Numeric.array([ [ 1-2*y*y-2*z*z, 2*x*y+2*w*z, 2*x*z-2*w*y, 0], [ 2*x*y-2*w*z, 1-2*x*x-2*z*z, 2*y*z+2*w*x, 0], [ 2*x*z+2*w*y, 2*y*z-2*w*x, 1-2*x*x-2*y*y, 0], [ 0,0,0,1], ]) def __getitem__( self, x ): return self.internal[x] def __len__( self ): return len( self.internal) def __repr__( self ): """Return a human-friendly representation of the quaternion Currently this representation is as an axis plus rotation (in radians) """ return """<%s XYZR=%s>"""%( self.__class__.__name__, list(self.XYZR())) def delta( self, other ): """Return the angle in radians between this quaternion and another. Return value is a positive angle in the range 0-pi representing the minimum angle between the two quaternion rotations. From code by Halldor Fannar on the 3D game development algos list """ #first get the dot-product of the two vectors cosValue = N.sum(self.internal + other.internal) # now get the positive angle in range 0-pi return acos( cosValue ) def __neg__(self): #return Quaternion(-self.a, -self.b, -self.c, -self.d) return Quaternion(-self.internal) #try: # import config # # if config.USE_TWISTED: # from twisted.spread import pb # # class CopyQuaternion(Quaternion, pb.Copyable, pb.RemoteCopy): # pass # # pb.setUnjellyableForClass('quaternion.CopyQuaternion', CopyQuaternion) #except: # pass #D3DRMQUATERNION is four floats x, y, z, s if __name__== "__main__": pass exploratio-0.1.1/lib/rdpyg/draw/0000755000175000017500000000000011311214451015164 5ustar renereneexploratio-0.1.1/lib/rdpyg/draw/__init__.py0000644000175000017500000000000011143032614017265 0ustar renereneexploratio-0.1.1/lib/rdpyg/draw/pygame/0000755000175000017500000000000011311214451016446 5ustar renereneexploratio-0.1.1/lib/rdpyg/draw/pygame/__init__.py0000644000175000017500000000000011143032613020546 0ustar renereneexploratio-0.1.1/lib/rdpyg/draw/pyopengl/0000755000175000017500000000000011311214451017021 5ustar renereneexploratio-0.1.1/lib/rdpyg/draw/pyopengl/__init__.py0000644000175000017500000000000011143032614021122 0ustar renereneexploratio-0.1.1/lib/rdpyg/draw/pyopengl/paths.py0000644000175000017500000000207411143032614020517 0ustar renerene from OpenGL.GL import glBegin, GL_LINES, glVertex3f, glEnd, glPushAttrib, GL_ALL_ATTRIB_BITS, glMatrixMode, GL_MODELVIEW, glLoadIdentity, glScale, glTranslatef, glPopAttrib from OpenGL.GLUT import glutSolidTeapot def draw_path(a_path): """ draws a path with opengl lines. """ glBegin(GL_LINES) try: last = 0 for x,y,z in a_path.points: if last: glVertex3f(lx,ly,lz) glVertex3f(x,y,z) lx, ly, lz = x,y,z else: last = 1 lx, ly, lz = x,y,z finally: glEnd() def draw_path_with_traveler(a_path): """ draws a box where the position of the traveler is on the path. """ #TODO: speed this up. take out the scale as well. draw_path(a_path) # Get where the traveler is, and draw something there. x,y,z = a_path.Where() ##glPushAttrib(GL_ALL_ATTRIB_BITS) ##glMatrixMode(GL_MODELVIEW) ##glLoadIdentity() ##glScale(0.2, 0.2, 0.2) glTranslatef(x,y,z) # now draw a teapot there. glutSolidTeapot(0.1) glTranslatef(-x,-y,-z) ##glPopAttrib() exploratio-0.1.1/lib/rdpyg/draw/pyopengl/particles.py0000755000175000017500000002221411143032614021367 0ustar renerene# purpose: particles. from OpenGL.GL import * #from OpenGL.GLU import gluPerspective import random from random import randint import os import pygame import pygame.image class Particle: def __init__(self): self.active = 0 self.life = 0. # fade speed. self.ifade = 0. # Red, green, blue values. self.r = 0. self.g = 0. self.b = 0. # x,y,z position. self.x = 0. self.y = 0. self.z = 0. # x,y,z direction. self.xi = 0. self.yi = 0. self.zi = 0. # x,y,z gravity. self.xg = 0. self.yg = 0. self.zg = 0. class cached_random: #def __init__(self, size_of_cache = 500): # self.size_of_cache = size_of_cache size_of_cache = 5000 rands100 = [] for x in range(size_of_cache): rands100.append(float(random.randint(1,100))) rands60 = [] for x in range(size_of_cache): rands60.append(float(random.randint(1,60))) rands30 = [] for x in range(size_of_cache): rands30.append(float(random.randint(1,30))) cursor30 = 0 cursor60 = 0 cursor100 = 0 def GetRandom100(self): self.cursor100 += 1 if(self.cursor100 >= self.size_of_cache): self.cursor100 = 0 return self.rands100[self.cursor100] def GetRandom60(self): #print self.cursor60 self.cursor60 += 1 if(self.cursor60 >= self.size_of_cache): self.cursor60 = 0 #print self.rands60[self.cursor60] return self.rands60[self.cursor60] def GetRandom30(self): self.cursor30 += 1 if(self.cursor30 >= self.size_of_cache): self.cursor30 = 0 return self.rands30[self.cursor30] class Particles: """ This is a set of particles baby. """ def __init__(self, num_particles): self.num_particles = num_particles if self.num_particles < 11: self.num_particles = 11 self.window = 0 self.zoom = -10 self.slowdown=2.0 self.xspeed = 5. self.yspeed = 2. self.col = 0 self.cube = None self.top = None self.rainbow = 1 self.delay = 0 self.particles = [] for x in range(self.num_particles): self.particles.append(Particle()) self.rand = cached_random() self.rand100 = self.rand.GetRandom100 self.rand60 = self.rand.GetRandom60 self.rand30 = self.rand.GetRandom30 self.colors = [ [1.0,0.5,0.5],[1.0,0.75,0.5],[1.0,1.0,0.5],[0.75,1.0,0.5], [0.5,1.0,0.5],[0.5,1.0,0.75],[0.5,1.0,1.0],[0.5,0.75,1.0], [0.5,0.5,1.0],[0.75,0.5,1.0],[1.0,0.5,1.0],[1.0,0.5,0.75] ] def _debug(self, s, x): pass def DisplayStateBegin(self): glEnable(GL_TEXTURE_2D) glDisable(GL_DEPTH_TEST) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA,GL_ONE) glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST) glHint(GL_POINT_SMOOTH_HINT,GL_NICEST) glBindTexture(GL_TEXTURE_2D, self.tex) def DisplayStateEnd(self): glDisable(GL_BLEND) glEnable(GL_DEPTH_TEST) glDisable(GL_TEXTURE_2D) def Update(self, elapsed_time): """ TODO: """ pass def Display(self): """ A default display. Which clears the color buffer and depth buffer. """ # Disables depth testing. #self.DisplayStateBegin() #TODO translate/rotate for position. self._debug("running display", 4) col0 = self.colors[self.col][0] col1 = self.colors[self.col][1] col2 = self.colors[self.col][2] rand100 = self.rand100 rand60 = self.rand60 slowdown1000 = self.slowdown * 1000 #particle = self.particles #for loop in range(len(self.particles)): for particle in self.particles: #if (particle.active): # Get our x,y,z x = particle.x y = particle.y #z = particle.z + self.zoom z = particle.z # Color it using our particles colors. glColor4f(particle.r,particle.g,particle.b,particle.life) glBegin(GL_TRIANGLE_STRIP); glTexCoord2d(1,1); glVertex3f(x+0.5,y+0.5,z); glTexCoord2d(0,1); glVertex3f(x-0.5,y+0.5,z); glTexCoord2d(1,0); glVertex3f(x+0.5,y-0.5,z); glTexCoord2d(0,0); glVertex3f(x-0.5,y-0.5,z); glEnd() particle.x+=particle.xi/(slowdown1000) particle.y+=particle.yi/(slowdown1000) #particle.z+=particle.zi/(slowdown1000) particle.xi+=particle.xg particle.yi+=particle.yg particle.zi+=particle.zg particle.life-=particle.fade if (particle.life<0.0): particle.life=1.0 particle.fade=(rand100())/1000.0+0.003 particle.x=0.0 particle.y=0.0 particle.z=0.0 particle.xi=self.xspeed+(rand60())-32.0 particle.yi=self.yspeed+(rand60())-30.0 particle.zi=(rand60())-30.0 particle.r=self.colors[self.col][0] particle.g=self.colors[self.col][1] particle.b=self.colors[self.col][2] particle.r=col0 particle.g=col1 particle.b=col2 self.delay += 1 if self.rainbow and self.delay > 25: self.delay = 0 self.col += 1 if self.col >= len(self.colors): self.col = 0 #self.col += 1 #if(self.col == 11): # self.col = 0 ##glTranslatef(0., 0., self.ztranslate) ##glRotatef(self.xrot, 1.0, 0.0, 0.0) ##glRotatef(self.yrot, 0.0, 1.0, 0.0) #glColor3fv(boxcol[yloop-1]) ##glCallList(self.cube); #glColor3fv(topcol[yloop-1]); ##glCallList(self.top); ##self.xrot+=1.0 ##if(self.xrot >= 360): ## self.xrot = 0. ##self.yrot+=1.0 ##if(self.yrot >= 360): ## self.yrot = 0. ##self.zrot+=1.0 ##if(self.zrot >= 360): ## self.zrot = 0. #self.DisplayStateEnd() def Load(self, with_tex = None, file_name = None): """ with_tex can be an opengl texture. """ if with_tex == None: if file_name == None: self.LoadImagePng(os.path.join("data", "images", "particle.png")) else: self.LoadImagePng(file_name) self.MakeTexture() else: self.tex = with_tex self.InitParticles() def InitParticles(self): particle = self.particles for loop in range(len(self.particles)): particle[loop].active=1 particle[loop].life=1.0 particle[loop].fade= (random.random() * 100) /1000.0+0.003 particle[loop].r=self.colors[loop/(self.num_particles/11)][0] particle[loop].g=self.colors[loop/(self.num_particles/11)][1] particle[loop].b=self.colors[loop/(self.num_particles/11)][2] particle[loop].xi=float( (random.random()*50)-26.0 )*10.0 particle[loop].yi=float( (random.random()*50)-26.0 )*10.0 particle[loop].zi=float( (random.random()*50)-26.0 )*10.0 particle[loop].xg=0.0 particle[loop].yg=-0.8 particle[loop].zg=0.0 def LoadImagePng(self, filename): im_surf = pygame.image.load(filename) self.imageWidth, self.imageHeight = im_surf.get_size() print "image size is:", im_surf.get_size() self.image = pygame.image.tostring(im_surf, "RGBX", 1) #self.image = pygame.image.tostring(im_surf, "RGBA", 1) def MakeTexture(self): #return self.tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, self.tex) #scale linearly when image bigger than texture glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR) #scale linearly when image smalled than texture glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR) # 2d texture, level of detail 0 (normal), # 3 components (red, green, blue), # x size from image, # y size from image, # border 0 (normal), # rgb color data, # unsigned byte data, # and finally the data itself. glTexImage2D(GL_TEXTURE_2D, 0, 3, self.imageWidth, self.imageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, self.image) #glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.imageWidth, self.imageHeight, 0, # GL_RGBA, GL_UNSIGNED_BYTE, self.image) exploratio-0.1.1/lib/rdpyg/net/0000755000175000017500000000000011311214451015015 5ustar renereneexploratio-0.1.1/lib/rdpyg/net/__init__.py0000644000175000017500000000004211143032613017123 0ustar renerene""" networking related stuff. """ exploratio-0.1.1/lib/rdpyg/net/ifconfig_networking.py0000755000175000017500000001666311143032613021442 0ustar renerene#import array, fcntl, struct, socket import os,sys,re,platform windows_output1 = """ Windows IP Configuration Ethernet adapter Network Bridge (Network Bridge): Connection-specific DNS Suffix . : IP Address. . . . . . . . . . . . : 192.168.0.10 Subnet Mask . . . . . . . . . . . : 255.255.255.0 Default Gateway . . . . . . . . . : 192.168.0.1 """ class IfConfigWindows: """ """ def _read_ipconfig(self): p = os.popen("ipconfig") address = p.read() p.close() return address def get_info(self, the_output = None): if the_output == None: output = self._read_ipconfig() else: output = the_output lines = output.split("\n") ip_addresses = [] subnet_masks = [] default_gateway = [] for l in lines: if "IP Address" in l: parts = l.split(":") ip_addr = parts[1].strip() ip_addresses.append(ip_addr) elif "Subnet Mask" in l: parts = l.split(":") ip_addr = parts[1].strip() subnet_masks.append(ip_addr) elif "Default Gateway" in l: parts = l.split(":") ip_addr = parts[1].strip() default_gateway.append(ip_addr) return [ip_addresses, subnet_masks, default_gateway] def get_ips(self, the_output = None): return self.get_info(the_output)[0] def get_subnet_masks(self, the_output = None): return self.get_info(the_output)[1] def get_default_gateways(self, the_output = None): return self.get_info(the_output)[2] linux_output2 = """eth0 Link encap:Ethernet HWaddr 00:0C:76:41:D5:E1 inet addr:64.251.25.208 Bcast:64.251.25.255 Mask:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:24222107 errors:0 dropped:0 overruns:0 frame:0 TX packets:1693415 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:2578326033 (2.4 GiB) TX bytes:287660600 (274.3 MiB) Interrupt:23 Base address:0xe400 eth0:1 Link encap:Ethernet HWaddr 00:0C:76:41:D5:E1 inet addr:64.251.25.209 Bcast:64.255.255.255 Mask:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 Interrupt:23 Base address:0xe400 eth0:2 Link encap:Ethernet HWaddr 00:0C:76:41:D5:E1 inet addr:64.251.25.210 Bcast:64.255.255.255 Mask:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 Interrupt:23 Base address:0xe400 lo Link encap:Local Loopback inet addr:127.0.0.1 Mask:255.0.0.0 UP LOOPBACK RUNNING MTU:16436 Metric:1 RX packets:407668 errors:0 dropped:0 overruns:0 frame:0 TX packets:407668 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:0 RX bytes:35240368 (33.6 MiB) TX bytes:35240368 (33.6 MiB) """ linux_output1 = """eth0 Link encap:Ethernet HWaddr 00:E0:81:23:7D:3A UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:92494052 errors:0 dropped:0 overruns:0 frame:0 TX packets:106532110 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:1940058549 (1850.1 Mb) TX bytes:657317003 (626.8 Mb) Interrupt:11 eth0:py3d Link encap:Ethernet HWaddr 00:E0:81:23:7D:3A inet addr:209.135.140.56 Bcast:209.135.140.255 Mask:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 Interrupt:11 lo Link encap:Local Loopback UP LOOPBACK RUNNING MTU:16436 Metric:1 RX packets:9500783 errors:0 dropped:0 overruns:0 frame:0 TX packets:9500783 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:0 RX bytes:3537945659 (3374.0 Mb) TX bytes:3537945659 (3374.0 Mb) """ class IfConfigLinux: def get_ips(self): output = p.read() print output p.close() def _read_ipconfig(self): p = os.popen("/sbin/ifconfig") output = p.read() p.close() return output def get_info(self, the_output = None): if the_output == None: output = self._read_ipconfig() else: output = the_output inet_regex = re.compile(r".*addr:(.*?)\s*[Bcast|Mask].*") lines = output.split("\n") ip_addresses = [] subnet_masks = [] default_gateway = [] info = {} info['ip_addresses'] = [] for l in lines: if "inet" in l: print l info['ip_addresses'].append(inet_regex.match(l).groups()[0]) return info def get_ips(self, the_output = None): return self.get_info(the_output)['ip_addresses'] # freebsd ifconfig output. """fxp0: flags=8843 mtu 1500 inet 207.142.132.145 netmask 0xffffff00 broadcast 207.142.132.255 inet 207.142.132.146 netmask 0xffffffff broadcast 207.142.132.146 inet 207.142.132.147 netmask 0xffffffff broadcast 207.142.132.147 inet 207.142.132.148 netmask 0xffffffff broadcast 207.142.132.148 inet 207.142.132.149 netmask 0xffffffff broadcast 207.142.132.149 ether 00:07:e9:08:d7:7c media: Ethernet autoselect (100baseTX ) status: active lp0: flags=8810 mtu 1500 lo0: flags=8049 mtu 16384 inet 127.0.0.1 netmask 0xff000000 """ class IfConfigFreeBSD: def get_info(self): raise NotImplementedError output = self._read_ipconfig() lines = output.split("\n") # keyed by interface name, valued by dicts containing various. interfaces = {} ip_addresses = [] subnet_masks = [] default_gateway = [] for l in lines: if "inet" in l: parts = l.split(":") ip_addr = parts[1].strip() ip_addresses.append(ip_addr) elif "Subnet Mask" in l: parts = l.split(":") ip_addr = parts[1].strip() subnet_masks.append(ip_addr) elif "Default Gateway" in l: parts = l.split(":") ip_addr = parts[1].strip() default_gateway.append(ip_addr) def _read_ifconfig(self): p = os.popen("/sbin/ifconfig") output = p.read() p.close() return output def IfConfig(): """ """ the_plat = platform.platform() if ('Microsoft' in the_plat or 'CYGWIN' in the_plat): return IfConfigWindows() elif('FreeBSD' in the_plat): return ifConfigFreeBSD() elif('Linux' in the_plat): return ifConfigFreeBsd() if __name__ == "__main__": i = IfConfigWindows() print i.get_ips(windows_output1) i = IfConfigLinux() print i.get_ips(linux_output1) print i.get_ips(linux_output2) i = IfConfig() print i.get_ips() exploratio-0.1.1/lib/rdpyg/app/0000755000175000017500000000000011311214451015007 5ustar renereneexploratio-0.1.1/lib/rdpyg/app/__init__.py0000644000175000017500000000005711143032613017123 0ustar renerene""" Common functionality for applications. """ exploratio-0.1.1/lib/rdpyg/app/the_app_gl.py0000755000175000017500000001045311143032613017472 0ustar renereneimport the_app import pygame from pygame.locals import DOUBLEBUF, OPENGL, FULLSCREEN, QUIT, KEYDOWN, K_ESCAPE from OpenGL.GL import glMatrixMode, GL_PROJECTION, glLoadIdentity, glClearColor, glClear, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, glGetFloatv, GL_PROJECTION_MATRIX, GL_MODELVIEW, glViewport, glGetDoublev, GL_MODELVIEW_MATRIX from OpenGL.GLU import gluPerspective, gluUnProject class TheAppGL(the_app.TheApp): def Display(self): """ A default display. Which clears the color buffer and depth buffer. """ self._debug("running display", 4) glClearColor(1.0, 1.0, 1.0, 0.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) def InitDisplay(self, width, height, first_time = 0): """ A default InitDisplay. """ self._debug("initializing display", 4) if first_time: full_display_flags = DOUBLEBUF | OPENGL | FULLSCREEN display_flags = DOUBLEBUF | OPENGL if self.full_screen: if pygame.display.mode_ok((width, height), display_flags ): self.screen = pygame.display.set_mode((width, height), display_flags) else: raise ValueError("error initializing display, can not get mode") if pygame.display.mode_ok((width, height), full_display_flags ): self.screen = pygame.display.set_mode((width, height), full_display_flags) else: raise ValueError("error initializing display, can not get mode") else: if pygame.display.mode_ok((width, height), display_flags ): self.screen = pygame.display.set_mode((width, height), display_flags) else: raise ValueError("error initializing display, can not get mode") else: if self.full_screen: display_flags = DOUBLEBUF | OPENGL | FULLSCREEN else: display_flags = DOUBLEBUF | OPENGL if pygame.display.mode_ok((width, height), display_flags ): self.screen = pygame.display.set_mode((width, height), display_flags) else: raise ValueError("error initializing display, can not get mode") def Start(self): """ """ self._debug("starting", 4) width, height = 640, 480 #width, height = 1024, 768 self.width, self.height = width, height self.InitDisplay(width, height, first_time = 1) glViewport(0,0, width, height) # sets up the projection matrix. self.SetupProjection(width, height) self.Load() def SetupProjection(self, width = 640, height = 480, zNear = 5., zFar = 300.): """ Sets up the projection matrix for opengl. """ # set the projection transformation glMatrixMode(GL_PROJECTION) glLoadIdentity() #TODO: replace the glu call with something else. #gluPerspective(45.0, float(width) / height, scale * 50.0, scale * 1000.0) #gluPerspective(45.0, float(self.width) / float(self.height), 5.0, 1000.0) self.zNear = zNear self.zFar = zFar self.buffer_calc_a = self.zFar / ( self.zFar - self.zNear ) self.buffer_calc_b = self.zFar * self.zNear / ( self.zNear - self.zFar ) gluPerspective(45.0, float(width) / float(height), self.zNear, self.zFar) self.gl_projection_matrix = glGetFloatv(GL_PROJECTION_MATRIX) # set the model transformation glMatrixMode(GL_MODELVIEW) def GetWorldCoords(self, x,y, camera_z): """ returns (x,y,z) given x,y pygame screen coords. NOTE: try and get the model view matrix back to the camera position when using. """ y = self.height - y mod = glGetDoublev(GL_MODELVIEW_MATRIX) proj = glGetDoublev(GL_PROJECTION_MATRIX) #view = glGetIntegerv(GL_VIEWPORT) view = (0, 0, self.width, self.height) z = abs(camera_z) z_buffer_value = self.buffer_calc_a +self.buffer_calc_b / z objx, objy, objz = gluUnProject(x,y,z_buffer_value, mod, proj,view) return (objx, objy, objz) exploratio-0.1.1/lib/rdpyg/app/the_app.py0000755000175000017500000002062211143032613017007 0ustar renerene#file: the_app.py #purpose: a base class for making applications from. """ TheApp is a class for making a game like application, implementing functionality common in many games. The idea is to make constructing games and demos quick, with minimal code. TODO: a way to chose between display flip and update. without overriding the whole method. There are a number of different methods with default implementations to save work. Most of these can be overridden if you need to specialise any parts. = How the main loop works. = TheApp class has a couple of different ways which it handles the main loop internally. It can use a while loop or the twisted reactor. However by using the methods provided you should not have to modify this. It can be instructional to have at a look at the source for different methods, so that overriding them can be easy. This is the 2d pygame version of the class. There is an opengl version named rdpyg.app.the_app_gl.TheAppGL = Commonly overridden methods = * Display * Your drawing code. * Update * Updating your game logic, game play, and game ai. * HandleEvents * Code to handle user input, operating system interaction, and other events. * Load * Code to load your game data. Like images, sounds etc. = Order of operation = The order in which the different methods get called is to update your game objects, handle user input, do your display changes. Start() InitDislpay() Load() Loop() Before loops starts looping: LoopInit() SetupTiming() Every 'tic' or frame of loop: Update() HandleEvents() DoBeforeDisplay() Display() DoAfterFlip() """ try: import config except: class blablablabla: USE_TWISTED = 0 full_screen = 0 config = blablablabla() import time import pygame from pygame.locals import DOUBLEBUF, OPENGL, FULLSCREEN, QUIT, KEYDOWN, K_ESCAPE # TODO: speed up loading time. this takes 0.2959 to load. if config.USE_TWISTED: import twisted.internet.reactor import traceback import sys class TheApp: """ An application class to handle lots of common things within games, and game like applications, using pygame. A lot of the methods are meant to be overrided. However they all come with sane default implementations. Useage: a = TheApp() a.Start() a.Loop() a.Stop() """ def __init__(self, debug_level = 0): self._debug_level = debug_level self.frames = 0 self.full_screen = config.full_screen def _debug(self, x, debug_level = 0): """ """ if self._debug_level > debug_level: print x def Display(self): """ This is called before the display is flipped(or updated). Your drawing code should go in here. """ self._debug("running display", 4) def InitDisplay(self, width, height, first_time = 0): """ A default InitDisplay. first_time - useful for working around some buggy systems. make it true if this is the first time calling it. """ self._debug("initializing display", 4) if first_time: full_display_flags = DOUBLEBUF | FULLSCREEN display_flags = DOUBLEBUF if self.full_screen: if pygame.display.mode_ok((width, height), display_flags ): self.screen = pygame.display.set_mode((width, height), display_flags) else: raise ValueError("error initializing display, can not get mode") if pygame.display.mode_ok((width, height), full_display_flags ): self.screen = pygame.display.set_mode((width, height), full_display_flags) else: raise ValueError("error initializing display, can not get mode") else: if pygame.display.mode_ok((width, height), display_flags ): self.screen = pygame.display.set_mode((width, height), display_flags) else: raise ValueError("error initializing display, can not get mode") else: if self.full_screen: display_flags = DOUBLEBUF | FULLSCREEN else: display_flags = DOUBLEBUF if pygame.display.mode_ok((width, height), display_flags ): self.screen = pygame.display.set_mode((width, height), display_flags) else: raise ValueError("error initializing display, can not get mode") def Stop(self): """ Called when we want to stop. """ pygame.quit() def Start(self): """ Do the game loading. """ self._debug("starting", 4) width, height = 640, 480 #width, height = 1024, 768 self.width, self.height = width, height self.InitDisplay(width, height, first_time = 1) self.Load() def Load(self): """ For loading stuff. """ def HandleEvents(self, event_list): """ should handle the events every game tic. """ for event in event_list: if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE): self.Stop() return 0 return 1 def Update(self, elapsed_time): """ update any game state. """ def OneTic(self): """ Does one game 'tic' worth of stuff. Should return 1 if not wanting to quit. If wanting to quit return 0. """ try: self.current_time, self.elapsed_time = self.TicTiming() if not self.DoBeforeHandlingEvents(): if config.USE_TWISTED: twisted.internet.reactor.stop() #self.Stop() return 0 else: return 0 self.Update(self.elapsed_time) event_list = pygame.event.get() if not self.HandleEvents(event_list): if config.USE_TWISTED: twisted.internet.reactor.stop() #self.Stop() return 0 else: return 0 self.DoBeforeDisplay() self.Display() #flip_time1 = time.time() pygame.display.flip() #flip_time2 = time.time() #flip_time = flip_time2 - flip_time1 #print "flip_time:", flip_time self.DoAfterFlip() self.frames += 1 self.last_time = self.current_time if config.USE_TWISTED: # run as fast as it can. twisted.internet.reactor.callLater(0.0, self.OneTic) else: return 1 except: traceback.print_exc(sys.stderr) # we have an error, quit instead. if config.USE_TWISTED: twisted.internet.reactor.stop() return 0 def DoAfterFlip(self): """ Called after flip is done. """ def DoBeforeDisplay(self): """ Stuff done before Display() is called. """ def DoBeforeHandlingEvents(self): """ Stuff done before we handle the events. Should return 0 to quit. """ return 1 def TicTiming(self): """ Call this once per tic to update the timing. """ current_time = time.time() elapsed_time = current_time - self.last_time self.total_elapsed_time += elapsed_time return (current_time, elapsed_time) def GetFps(self): """ Returns the frames per second since the timing has begun. """ if self.total_elapsed_time == 0: return 0. return self.frames/self.total_elapsed_time def LoopInit(self): """ Should put use loop initialisation stuff here. """ def SetupTiming(self): """ Sets up some timing code. """ self.last_time = time.time() self.total_elapsed_time = 0. def Loop(self): """ Starts the game looping. Will eventually return. """ self.LoopInit() self.SetupTiming() if config.USE_TWISTED: twisted.internet.reactor.callLater(0.0, self.OneTic) twisted.internet.reactor.run() else: while 1: if not self.OneTic(): break exploratio-0.1.1/lib/rdpyg/sprites/0000755000175000017500000000000011311214451015720 5ustar renereneexploratio-0.1.1/lib/rdpyg/sprites/__init__.py0000644000175000017500000000000011143032613020020 0ustar renereneexploratio-0.1.1/lib/rdpyg/sprites/spritegl.py0000644000175000017500000005470511143032613020137 0ustar renerene""" Opengl drawing of pygame.sprite objects. With hopefully minimal/no changes to programs, and big speed increases. Rene Dudfield. illumen@yahoo.com TODO: First compatibilty, optimization, then next gen. NOTE: there are some more TODO's sprinkled througout the code Compatibilty. - need to implement all of screens methods. - test on more games. - chimp(works). - pyddr(doesn't work). - I think it has to do with the different format images. - I think a conversion may not be working properly. - bleten(works). - works, but is kinda slow when lots of images change. - need to work on a scaling method which uses opengl. - need to not use tostring() for making textures(slow). - work on caching some more, so that there is a texture cache as well. - so that images don't need to be uploaded to the card all the time. - yass(don't know). - a better way to detect when an images contents have changed. - probably a wrapper around surface, and surfarray which marks the image as dirty. - split sprites larger than 256x256 into multiple smaller textures. - for some older 3d cards. - should figure out how to detect max texture size. - support 8 and 16 bit and color keyed textures. - Make sure textures are cleaned up correctly in all cases. - Beta test on a wide number of machines. - Make it work correctly when the screen size changes. Optimization. - Put multiple sprites onto the same texture, and use uv coords for drawing particular sprites. This is a *big* optimization. - especially for animation. - move all texture management into the group, so as to optimize texture drawing more easily. - Have a set max number of textures to use in a texture cache. - Cache textures - optimize the screen.blit function, and some others: - with blit, only update a certain part of the texture which was actually blitted. - screen.fill - Group drawing by the same texture(less texture binds). - Try display lists to see if better performing. - try vertex buffers for better performance. - Make 1000+ sprite test case, and optimize for this case. - Update texture instead of replacing it when: - some pixels change in an image. - when the image changes and the old one isn't to be used anymore. - How to know this? Next gen. - Add scaling, rotation, other effects to a sprite class. - use caching of images for sdl, and straight opengl calls(eg glRotate etc). - shadows from sprites onto the background. - Make classes/optimize existing classes for drawing: - scrollers, tile maps, height maps, - 3d animated characters (http://www.py3d.org/py3d_zwiki/milkshape3d_animation) - doomIII clone ;) """ # search and replace this for __debug__ for a bit of a speed increase in -O _debug__ = 0 #Import Modules import os, pygame from pygame.locals import * from OpenGL.GL import * #from OpenGL.GLUT import * from OpenGL.GLU import * import time """ old_glMatrixMode = glMatrixMode def glMatrixMode(*args): modes = {GL_PROJECTION: "GL_PROJECTION", GL_MODELVIEW: "GL_MODELVIEW"} if _debug__: printw( glMatrixMode, modes[args[0]]) return apply(old_glMatrixMode, args) old_glTexSubImage2D = glTexSubImage2D def glTexSubImage2D(*args): if _debug__: printw( "glTexSubImage2D"+ str(args[:-1])) apply(old_glTexSubImage2D, args) """ #from _opengl2 import glVertexPointer, glColorPointer, glNormalPointer, glTexCoordPointer #from _opengl2 import glVertexPointer, glColorPointer, glNormalPointer#, glTexCoordPointer #from _opengl2 import glTexCoordPointer """ In order of easyness. make a draw method for the group. replace screen.blit with one which will work. make an update method. """ POWERS = (32, 64, 128, 256, 512, 1024, 2048, 4096) def nextPower(x): for y in POWERS: if y >= x: return y def printw(*args): print args from rdpyg.util import pack_textures #NOTE: TODO: maybe we shouldn't be using a subclass of Surface... pygame.old_Surface = pygame.Surface #class SurfaceGL(pygame.old_Surface): class SurfaceGL: """ This is useful for tracking changes in a surface. It takes a surface as a keyword initializer: eg s = SurfaceGL(initialize_with_this = a_surf) Or you can initialize it like a normal surface. Once the pixel data is changed, either is_dirty will be true, or changed_rects will not be empty. If is_dirty is true: then the whole image needs to be updated. Else: if changed_rects is not empty: update the rects which have been changed. """ def __init__(self, *args, **kwargs): if kwargs.has_key("initialize_with_this"): self.__dict__["realone"] = kwargs["initialize_with_this"] else: self.__dict__["realone"] = pygame.old_Surface(*args, **kwargs) # If this is dirty(ie has changed) then the whole image should # be reuploaded. Otherwise the rects from self.changed_rects will # be used for updating the image. self.__dict__["is_dirty"] = 0 # this is a list of rects to use when you only want to update a small # part of the image. self.__dict__["changed_areas"] = [] def __getattr__(self, name): if name == "realone": if self.__dict__.has_key("realone"): return self.__dict__["realone"] else: raise AttributeError(name) elif self.__dict__.has_key("realone"): if hasattr(self.__dict__["realone"], name): return getattr(self.__dict__["realone"], name) else: raise AttributeError(name) elif self.__dict__.has_key(name): return self.__dict__[name] else: print self.__dict__ raise AttributeError(name) def __setattr__(self, name, value): #print "ASDDFFAFDF", name, value if name in ["realone", "is_dirty", "changed_rects"]: self.__dict__[name] = value else: setattr(self.__dict__["realone"],name, value) def blit(self, *args): """ TODO: needs to keep track of which parts have been changed. For now marking the whole image as dirty. """ self.__dict__["is_dirty"] = 1 print type(args[0]) print dir(args[0]) # we need a real surface type for blit. if hasattr(args[0], "realone"): new_args = list(args) new_args[0] = args[0].realone args = tuple(new_args) if hasattr(args[0], "screen_gl"): new_args = list(args) new_args[0] = args[0].screen_gl.image args = tuple(new_args) return self.__dict__["realone"].blit(*args) def fill(self, *args): """ like a normal surface fill, but marks the thing as dirty. """ self.__dict__["is_dirty"] = 1 return self.__dict__["realone"].fill(*args) #pygame.sprite.Group_orig = pygame.sprite.Group #pygame.sprite.Sprite_orig = pygame.sprite.Sprite class GroupGL(pygame.sprite.Group) : def setup_draw_texture(self, screen_rect): """ Sets up opengl for drawing the textures. """ self.old_matrix_mode = glGetIntegerv(GL_MATRIX_MODE); if _debug__: printw( type(self.old_matrix_mode), self.old_matrix_mode) self.old_projection_matrix = glGetDoublev( GL_PROJECTION_MATRIX ) self.old_modelview_matrix = glGetDoublev( GL_MODELVIEW_MATRIX ) self.set_up_2d_projection(screen_rect) glEnable(GL_TEXTURE_2D) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) if _debug__: printw( "setup_draw_texture") glMatrixMode( GL_MODELVIEW ) self.has_setup = 1 def un_setup_draw_texture(self): """ resets the opengl state to what it was before drawing. """ if _debug__: printw( type(self.old_matrix_mode), self.old_matrix_mode) if self.old_matrix_mode: glMatrixMode( self.old_matrix_mode ) glDisable(GL_BLEND) glDisable(GL_TEXTURE_2D) if _debug__: printw( "un_setup_draw_texture1") glMatrixMode( GL_PROJECTION ) glLoadMatrixd(self.old_projection_matrix ) if _debug__: printw( "un_setup_draw_texture2") glMatrixMode( GL_MODELVIEW ) glLoadMatrixd( self.old_modelview_matrix ) self.has_setup = 0 def draw_gl(self, spr ): """ Assumes glMatrixMode( GL_MODELVIEW ) """ #glLoadIdentity() glBindTexture(GL_TEXTURE_2D, spr.tex) x = spr.rect[0] y = spr.rect[1] glTranslatef(x, y, 0) wv, hv = float(spr.rect.width)/float(spr.pow2_image_width), float(spr.rect.height)/float(spr.pow2_image_height) glBegin(GL_QUADS) glTexCoord2f(0.0, 0.0) glVertex2f(0.0, 0.0) glTexCoord2f(0.0, hv) glVertex2f(0, spr.rect.height) glTexCoord2f(wv, hv) glVertex2f(spr.rect.width, spr.rect.height) glTexCoord2f(wv, 0.0) glVertex2f(spr.rect.width, 0) glEnd() glTranslatef(-x, -y, 0) #(x, y), texid, (owidth, oheight), (width, height), #(xres, yres)): def set_up_2d_projection(self, a_rect): """ a_rect - the area to set up the projection for. """ if _debug__: printw( "set_up_2d_projection") glMatrixMode( GL_PROJECTION ) glLoadIdentity() gluOrtho2D( a_rect[0], a_rect.width, a_rect.height, a_rect[1]) def load_2d_projection(self): if _debug__: printw( "load_2d_projection") glMatrixMode( GL_PROJECTION ) glLoadMatrixd(self.projection_matrix_2d) def draw(self, surface ): """ supposed to draw to the given surface. Problem is it is an opengl screen. so we get the size of it, and draw to the screen. """ # TODO: OPTIMIZATION: order the sprites into ones which share the same textures. # TODO: OPTIMIZATION: make sure the texture is only loaded once for each image. if not hasattr(self, 'has_setup'): self.setup_draw_texture(surface.get_rect()) #damn, if not hasattr(self, 'has_setup') or not self.has_setup: # doesn't work. if not self.has_setup: self.setup_draw_texture(surface.get_rect()) glLoadIdentity() for spr,k in self.spritedict.items(): # see if the texture has been made for the things, if not # make them. if not hasattr(spr, 'image_string'): spr.LoadImage() if not hasattr(spr, 'tex'): spr.MakeTexture() if not hasattr(spr, 'old_rect'): spr.old_rect = pygame.Rect( spr.rect ) if not hasattr(spr, 'old_image_id'): spr.old_image_id = id( spr.image ) reload_the_texture = 0 # TODO: BUG: if the if spr.old_rect[2:] != spr.rect[2:] or spr.old_image_id != id( spr.image ): reload_the_texture = 1 if reload_the_texture: # TODO: FIXME: should probably check if the screen changes too. spr.DeleteTexture() spr.LoadImage() spr.MakeTexture() spr.old_rect = pygame.Rect( spr.rect ) spr.old_image_id = id( spr.image ) spr.pow2_image_width, spr.pow2_image_height = tuple(map( nextPower,(spr.rect.width, spr.rect.height) )) self.set_up_2d_projection(surface.get_rect()) glMatrixMode( GL_MODELVIEW ) self.draw_gl(spr) # this is here for compatibility with RenderUpdates return [] #self.un_setup_draw_texture() def MakeTextures(self): """ For all of the sprites in this group we will make textures for them. """ # TODO: make list of pack_textures.Textures for all the surfaces. # Figure out how big a texture we want to make. # Find the maximum texture size we can make. # find the smallest sized textures we can fit all the little # ones inside. # TODO: to draw we need to: # Bind the gl texture for each main texture. # Draw a bunch of quads using the x/y in the sub textures as # the uv coordinates. # def FitSpritesOnTextures(self): """ """ # get the max texture size. self.max_texture_size = (256, 256) class SpriteGL(pygame.sprite.Sprite): """ A sprite class which uses opengl. Should be able to use it in the place of the pygame sprite class. """ # a shared image cache. image_cache = {} max_image = 30 def update(self): pass def LoadImage(self): # The image should allready be loaded, and rect allready there. #self.image = pygame.image.load(filename) if _debug__: printw( "SpriteGL.LoadImage start") if not hasattr(self, 'rect'): self.rect = self.image.get_rect() # check if it is an alpha image. self.masks = self.image.get_masks() alpha_mask = self.masks[3] if _debug__: printw( self.masks, id(self)) #TODO: FIXME: better detection, and manipulation of different image # types. if _debug__: printw( "byte_size") printw( self.image.get_bytesize()) printw( self.masks) # DEPENDENCY - self.image # See if the image has changed. # If it has we need to update the texture. # # if self.image_cache.has_key((id(self.image),tuple(self.rect[2:])) ): if _debug__: printw( "SpriteGL.LoadImage: image_cache") self.image_string, rect, self.cache_tex = self.image_cache[(id(self.image),tuple(self.rect[2:]))] self.cache_hit = 1 elif not alpha_mask: if _debug__: printw( "SpriteGL.LoadImage: not alpha_mask") ##raise "ummmmm... not implemented, sorry" ##self.image_string = pygame.image.tostring(self.image, "RGB", 0) ##self.image_cache[(id(self.image),tuple(self.rect[2:]))] = [self.image_string, self.image.get_rect(), -1] ##self.cache_hit = 0 #TODO: OPTIMIZATION: need to have this handle non alpha images. # for now we convert it to an alpha one. #TODO: I don't think this works with 8 bit images. # need to test with different images. self.image = self.image.convert_alpha() if _debug__: printw( "self.image", self.image) self.masks = self.image.get_masks() alpha_mask = self.masks[3] if _debug__: if not alpha_mask: raise "problem here" self.image_string = pygame.image.tostring(self.image, "RGBA", 0) self.image_cache[(id(self.image),tuple(self.rect[2:]))] = [self.image_string, self.image.get_rect(), -1] self.cache_hit = 0 else: if _debug__: printw( "SpriteGL.LoadImage: else") self.image_string = pygame.image.tostring(self.image, "RGBA", 0) self.image_cache[(id(self.image),tuple(self.rect[2:]))] = [self.image_string, self.image.get_rect(), -1] self.cache_hit = 0 if hasattr(self, 'pow2_image_width') and hasattr(self, 'pow2_image_height'): self.old_pow2_image_width, self.old_pow2_image_height = self.pow2_image_width, self.pow2_image_height self.pow2_image_width, self.pow2_image_height = tuple(map(nextPower,self.image.get_size())) if self.old_pow2_image_width > self.pow2_image_width: self.pow2_image_width = self.old_pow2_image_width if self.old_pow2_image_height> self.pow2_image_height: self.pow2_image_height= self.old_pow2_image_height else: self.pow2_image_width, self.pow2_image_height = tuple(map(nextPower,self.image.get_size())) #TODO: make glTexImage2D version which can take surfaces directly. def DeleteTexture(self): if hasattr(self, 'tex'): if _debug__: printw( self.tex) glDeleteTextures([self.tex]) def load_del_make(self): """ """ def MakeTexture(self): #return if _debug__: printw( "SpriteGL.MakeTexture start") #if self.cache_tex != -1: # TODO: probably need to move texture making into the group. # need to keep a dict of cached textures. # delete those which are not needed etc. # For grouping textures, need to discover a list of texids, with images. # pass #self._debug("making texture") self.tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, self.tex) #glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) #scale linearly when image bigger than texture glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR) #scale linearly when image smalled than texture glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR) # 2d texture, level of detail 0 (normal), # 3 components (red, green, blue), # x size from image, # y size from image, # border 0 (normal), # rgb color data, # unsigned byte data, # and finally the data itself. #TODO: check to see what type of image was loaded, and make # and appropriate glTexImage2D call. #TODO: use the rect for the image size, width etc. #TODO: need to take power of 2 into account here. """ if _debug__: printw( self.rect.width) printw( self.rect.height) printw( self.image.get_width()) printw( self.image.get_height()) printw( len(self.image_string)) printw( type(self.image_string)) printw( GL_RGB) printw( GL_RGBA) """ self.pow2_image_width, self.pow2_image_height = tuple(map(nextPower,self.image.get_size())) if _debug__: printw( self.pow2_image_width, self.pow2_image_height) if not self.masks[3]: if _debug__: printw( "glTexImage2D RGB") glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, self.pow2_image_width, self.pow2_image_height, 0, GL_RGB, GL_UNSIGNED_BYTE, None) glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, self.rect.width, self.rect.height, GL_RGB, GL_UNSIGNED_BYTE, self.image_string) else: if _debug__: printw( "glTexImage2D RGBA") glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.pow2_image_width, self.pow2_image_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, None) glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, self.rect.width, self.rect.height, GL_RGBA, GL_UNSIGNED_BYTE, self.image_string) #glTexImage2D(GL_TEXTURE_2D, 0, 4, self.image_width, self.image_height, 0, # GL_RGBA, GL_UNSIGNED_BYTE, self.image_string) # GL_RGBA, GL_UNSIGNED_BYTE, self.image) """ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, None) glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, owidth, oheight, GL_RGBA, GL_UNSIGNED_BYTE, imgstring) """ #self._debug("finished making texture") class ScreenGL: """ TODO: - Fill in missing functions. - Work correctly when screen size changes. - only update the texture when blitting. - An optimization might be to not update the texture until the screen has been flipped, or updated. - This could work quite nicely with RenderUpdates :) """ def __init__(self, screen): self.screen = screen self.screen_gl = SpriteGL() self.screen_gl.image = pygame.Surface(screen.get_size()) self.screen_gl.image.convert_alpha() self.screen_gl.rect = self.screen_gl.image.get_rect() self.screen_sprites= GroupGL((self.screen_gl)) #TODO: automatically add all the methods of surface # What's a nice way to do this in python? # def get_size(self, *args): return apply(self.screen_gl.image.get_size, args) def get_rect(self, *args): return apply(self.screen_gl.image.get_rect, args) def set_clip(self, *args): return apply(self.screen_gl.image.set_clip, args) def get_clip(self, *args): return apply(self.screen_gl.image.get_clip, args) def get_flags(self, *args): return apply(self.screen_gl.image.get_flags, args) def fill(self, *args): apply(self.screen_gl.image.fill, args) self.blit(None) def blit(self, *args): """ meant as a replacement for screen.blit You really should consider making your background a seperate Sprite, and Group. useage: gl_screen_blit """ ##print "blit" #print "args", args[0:1], args # blit to the internal software image here. if (None,) != args[0:1]: if hasattr(args[0], "realone"): new_args = list(args) new_args[0] = args[0].realone args = tuple(new_args) self.screen_gl.image.blit(*args) if _debug__: printw( "blitting to ScreenGL, with args :%s:" % (args,)) #screen_sprites.update() # write the internal image to disk. """ pygame.image.save(self.screen_gl.image, "/tmp/screen.tga") printw("sleeping for 2") time.sleep(20) printw("finished sleeping") """ self.screen_gl.DeleteTexture() self.screen_gl.LoadImage() self.screen_gl.MakeTexture() #self.screen_sprites.setup_draw_texture(self.screen_gl.image.get_rect()) self.screen_sprites.update() self.screen_sprites.draw(self.screen) ##print "done draw" #self.screen_sprites.un_setup_draw_texture() #screen_gl.DeleteTexture() def gl_display_get_surface(): return pygame.display.old_get_surface() def gl_display_set_mode(*args): # TODO: Add check to see if a GL screen is infact being requested. return ScreenGL( pygame.display.old_set_mode(args[0], OPENGL|DOUBLEBUF) ) #return ScreenGL( apply(pygame.display.old_set_mode, args) ) def gl_display_update(*args): pygame.display.flip() def gl_draw_line(*args): if hasattr(args[0], "realone"): args[0].is_dirty = 1 new_args = list(args) new_args[0] = args[0].realone args = tuple(new_args) return pygame.draw.old_line(*args) def gl_transform_scale(*args, **kwargs): print "len args", len(args) if hasattr(args[0], "realone"): new_args = list(args) new_args[0] = args[0].realone args = tuple(new_args) elif hasattr(args[0], "screen_gl"): new_args = list(args) new_args[0] = args[0].screen_gl.image args = tuple(new_args) #print kwargs, args if len(args) > 2: new_surface = pygame.transform.old_scale(*args[1:], **kwargs) else: new_surface = pygame.transform.old_scale(*args, **kwargs) return pygame.Surface(initialize_with_this = new_surface) #pygame.display.get_surface() and pygame.display.set_mode((height,width), OPENGL|DOUBLEBUF) exploratio-0.1.1/lib/game.py0000755000175000017500000000405211310703111014364 0ustar renerene""" An object representing a game... or game sequence. This is how each Game object is called. # the constructor calls the load() method too. g = Game() in loop: g.handle_events(events) g.update(elapsed_time_since_last_frame) rects_dirtied = g.draw(screen) """ import pygame from pygame.locals import * class Game(object): def __init__(self, going = True, games = None, name = "", elapsed_time = 0.0): """ going - if this is going. games - children game objects. name - elapsed_time - """ self.going = going # a list of children game objects. if not games: self.games = [] else: self.games = games self.name = name self.elapsed_time = elapsed_time self.load() def handle_events(self, events): for g in self.games: if g.going: g.handle_events(events) #print "handling..." #print g else: pass #print g def update(self, elapsed_time): # update the internal elapsed_time counter. self.elapsed_time += elapsed_time # update the rest of the children games. for g in self.games: if g.going: g.update(elapsed_time) def draw(self, screen): rects = [] # draw all of the children games. for g in self.games: if g.going: sub_rects = g.draw(screen) rects.extend( sub_rects ) return rects def stop(self): self.going = False def start(self): self.going = True self.elapsed_time = 0.0 def load(self): """ called to load data. """ pass def set_main(self): """ sets this to the main game being used. """ pygame.display.set_caption(self.name) pygame.event.pump() exploratio-0.1.1/lib/constants.py0000644000175000017500000000047211310720674015503 0ustar renereneimport pygame PITCH_DETECT = pygame.USEREVENT + 10 VIDEO_PLAYER = pygame.USEREVENT + 11 FPS = 30 SCREEN_SIZE = (640,480) # how much time do they have to get a note? TIME_MS_TO_GET_NOTE = 200 # other constants can go here! yes indeed... INTRO_FADEOUT = pygame.USEREVENT + 2 exploratio-0.1.1/lib/data.py0000755000175000017500000000121511310704257014376 0ustar renerene'''Simple data loader module. Loads data files from the "data" directory shipped with a game. Enhancing this to handle caching etc. is left as an exercise for the reader. ''' import os #data_py = os.path.abspath(os.path.dirname(__file__)) #data_dir = os.path.normpath(os.path.join(data_py, '..', 'data')) data_dir = 'data' def filepath(filename): '''Determine the path to a file in the data directory. ''' return os.path.join(data_dir, filename) def load(filename, mode='rb'): '''Open a file in the data directory. "mode" is passed as the second arg to open(). ''' return open(os.path.join(data_dir, filename), mode) exploratio-0.1.1/lib/hiro.py0000644000175000017500000000513511311213532014420 0ustar renereneimport pygame from pygame.locals import * import game import particles import os class Hiro(game.Game): def load(self): game.Game.load(self) self.load_real() def load_real(self): self.image = pygame.image.load(os.path.join('data', 'gfx', 'hiro.png')) self.rect = self.image.get_rect().copy() self.rect.y = 170 # load hiro image # continual burning near the flares. def add_small_flare(self): self.small_flare = particles.FlareSmall() self.games.append( self.small_flare) pos = self.rect.x + 55, self.rect.y - 35 self.games[-1].lighting = self.lighting self.games[-1].load_real(direction=1, pos = pos) self.small_flare2 = particles.FlareSmall() self.games.append( self.small_flare2) pos = self.rect.x, self.rect.y + 15 self.games[-1].lighting = self.lighting self.games[-1].load_real(direction=1, pos = pos) def handle_events(self, events): for e in events: if e.type == KEYDOWN: if e.key in [K_RIGHT]: self.right() if e.key in [K_LEFT]: self.left() if e.key in [K_UP]: self.flare_up() if e.key in [K_DOWN]: self.flare_down() def left(self): self.rect.move_ip(-10,0) pass def right(self): self.rect.move_ip(10,0) pass def flare_up(self): pass self.games.append( particles.Flare() ) pos = self.rect.x + 55, self.rect.y + 35 self.games[-1].lighting = self.lighting self.games[-1].load_real(direction=1, pos = pos) def flare_down(self): pass def update(self, elapsed_time): game.Game.update(self, elapsed_time) # check to see if any of the flares are dead, and remove them. flares = [f for f in self.games if type(f) == particles.Flare] for f in flares: if hasattr(f, "dead") and f.dead: self.games.remove(f) pos = self.rect.x + 25, self.rect.y - 15 self.small_flare.x = pos[0] self.small_flare.y = pos[1] pos = self.rect.x-10, self.rect.y + 80 self.small_flare2.x = pos[0] self.small_flare2.y = pos[1] # collision detection/response with things. def draw(self, screen): rect = screen.blit(self.image, self.rect) sub_rects = game.Game.draw(self, screen) rects = [rect] + sub_rects # draw the flares onto the lighting layer. return rects exploratio-0.1.1/lib/particles.py0000644000175000017500000003027511311213730015450 0ustar renerene""" a simple particle system. Particles For The Win!!!! PFTW. """ import pygame import random, time import numpy import game # data types for numpy record defining the types needed for particle systems. particle_dtype = [ ('active', '0] point_list = zip(p.x, p.y) color = (255,0,0,255) closed = 0 r = pygame.draw.aalines(screen, color, closed, point_list) rects.append(r) if 0: for r,g,b,life, x,y in zip(p.r, p.g, p.b, p.life, p.x, p.y): if life > 0: rect = (x,y, 10,10) #rect = (x,y, random.randrange(2,20), random.randrange(2,20)) color = (r,g,b,min(life, 255)) screen.fill(color, rect) #pygame.draw.rect(screen, color, rect) rects.append(rect) if 1: w,h = 5,5 surf = pygame.Surface((w,h)).convert_alpha() all_dead = True for r,g,b,life, x,y in zip(p.r, p.g, p.b, p.life, p.x, p.y): if life > 0: all_dead = False rect = (x,y, w,h) #color = (r,g,b,min(life, 255)) color = (r,g,b,min(life, 127)) surf.fill(color) screen.blit(surf, rect) #pygame.draw.rect(screen, color, rect) rects.append(rect) if all_dead: self.dead = True return rects class Flare(Particles): def load(self): game.Game.load(self) # left -1, right +1 #self.direction = 1 #self.direction = -1 #self.load_real(direction, pos) def load_real(self, direction=-1, pos =(0,0)): self.dead = False self.direction = direction self.x, self.y = pos # init the particles. self.max_particles = 100 self.zoom = 0 self.slowdown=0.5 self.xspeed = 5. self.yspeed = 2. # create a whole bunch of lists... data = [[0 for x in range(len(particle_dtype))] for x in range(self.max_particles)] self.particles = numpy.rec.array(data, dtype=particle_dtype) self.start_particles() def start_particles(self): """ start_particles() starts the particles up! """ particles = self.particles num_particles = len(particles) #particles.x, particles.y, particles.z = 50, 50, 50 particles.x, particles.y = self.x, self.y particles.fade = [random.randrange(1, 25) for x in range(num_particles)] particles.life = 300 if self.direction == -1: xi_left = -1000 xi_right = -500 if self.direction == 1: xi_left = 500 xi_right = 1000 particles.xi=[self.xspeed+random.randrange(xi_left, xi_right) for x in range(num_particles)] particles.yi=[self.yspeed+random.randrange(-2500, -1500) for x in range(num_particles)] particles.zi=0 # gravity is 9.81m/s^2 #particles.xg, particles.yg, particles.zg = 0.,-0.981 * -10, 0. #particles.xg, particles.yg = 23.,-0.981 * -10 #particles.xg=[random.randrange(-50, 50) for x in range(num_particles)] particles.xg= 0. particles.yg=[random.randrange(10, 50) for x in range(num_particles)] particles.r, particles.g, particles.b, a = pygame.Color("red") def handle_events(self, events): for e in events: if e.type == pygame.locals.KEYDOWN: if e.key == pygame.locals.K_p: self.start_particles() def draw(self, screen): 'flare' rects = game.Game.draw(self, screen) def rects_colors_for_particles(self): p = self.particles w,h = 5,5 rects = [] colors = [] all_dead = True for r,g,b,life, x,y in zip(p.r, p.g, p.b, p.life, p.x, p.y): if life > 0: all_dead = False rect = (x,y, w,h) color = (r,g,b,min(life, 127)) rects.append(rect) colors.append(color) if all_dead: self.dead = True return rects, colors def draw(self, screen): rects, colors = self.rects_colors_for_particles() if not rects: return [] w,h = rects[0][2], rects[0][3] surf = pygame.Surface((w,h)).convert_alpha() surf2 = pygame.Surface((w,h)).convert_alpha() lighting = self.lighting color = (0,0,0,127) surf.fill(color) color2 = (0,0,0,127) surf2.fill(color) for rect, color in zip(rects, colors): lighting.blit(surf, rect, None, pygame.locals.BLEND_RGBA_SUB) #lighting.blit(surf2, rect) #lighting.fill(color, rect, pygame.locals.BLEND_RGBA_SUB) #screen.blit(surf, rect) #pygame.draw.rect(screen, color, rect) return rects class FlareSmall(Particles): def load(self): game.Game.load(self) def load_real(self, direction=-1, pos =(0,0)): self.dead = False self.direction = direction self.x, self.y = pos # init the particles. self.max_particles = 300 self.zoom = 0 self.slowdown=0.5 self.xspeed = 5. self.yspeed = 2. # create a whole bunch of lists... data = [[0 for x in range(len(particle_dtype))] for x in range(self.max_particles)] self.particles = numpy.rec.array(data, dtype=particle_dtype) self.start_particles() def update(self, elapsed_time): Particles.update(self, elapsed_time) particles = self.particles slowdown1000 = self.slowdown * 1000 particles.x+=particles.xi/(slowdown1000) #particles.x = numpy.minimum( particles.x, self.x-30) #particles.y = numpy.minimum( particles.y, self.y-30) def start_particles(self): """ start_particles() starts the particles up! """ self.dead = False particles = self.particles num_particles = len(particles) #particles.x, particles.y, particles.z = 50, 50, 50 particles.x, particles.y = self.x, self.y particles.fade = [random.randrange(4, 5) for x in range(num_particles)] particles.life = random.randrange(40, 500) particles.life = 0 if self.direction == -1: xi_left = -100 xi_right = -50 if self.direction == 1: xi_left = 50 xi_right = 100 particles.xi=[self.xspeed+random.randrange(-100,100) for x in range(num_particles)] particles.yi=[self.yspeed+random.randrange(-250, -150) for x in range(num_particles)] particles.zi=0 # gravity is 9.81m/s^2 #particles.xg, particles.yg, particles.zg = 0.,-0.981 * -10, 0. #particles.xg, particles.yg = 23.,-0.981 * -10 #particles.xg=[random.randrange(-50, 50) for x in range(num_particles)] particles.xg= 0. particles.yg=[random.randrange(10, 50) for x in range(num_particles)] particles.r, particles.g, particles.b, a = pygame.Color("red") def handle_events(self, events): for e in events: if e.type == pygame.locals.KEYDOWN: if e.key == pygame.locals.K_p: self.start_particles() def draw(self, screen): 'flare' rects = game.Game.draw(self, screen) def rects_colors_for_particles(self): p = self.particles particles = self.particles w,h = 5, 5 rects = [] colors = [] idx = 0 for life, x,y in zip(p.life, p.x, p.y): if life <= 0: particles.x[idx], particles.y[idx] = self.x+20, self.y particles.life[idx] = random.randrange(40, 500) particles.xi[idx]=self.xspeed+random.randrange(-150,150) particles.yi[idx]=self.yspeed+random.randrange(-250, -150) particles.xg[idx]= 0. particles.yg[idx]=random.randrange(10, 50) rect = (x,y, w,h) color = (255,255,255,min(life, 127)) rects.append(rect) colors.append(color) idx +=1 return rects, colors def draw(self, screen): rects, colors = self.rects_colors_for_particles() if not rects: return [] w,h = rects[0][2], rects[0][3] surf = pygame.Surface((w,h)).convert_alpha() surf2 = pygame.Surface((w,h)).convert_alpha() lighting = self.lighting color = (0,0,0,127) surf.fill(color) color2 = (0,0,0,127) surf2.fill(color) for rect, color in zip(rects, colors): lighting.blit(surf, rect, None, pygame.locals.BLEND_RGBA_SUB) #lighting.blit(surf2, rect) #lighting.fill(color, rect, pygame.locals.BLEND_RGBA_SUB) #screen.blit(surf, rect) #pygame.draw.rect(screen, color, rect) return rects exploratio-0.1.1/lib/main.py0000755000175000017500000001201411311210053014373 0ustar renerene""" game.Game main module. """ import os,sys import pygame from pygame.locals import * import numpy try: pygame.sndarray.use_arraytype("numpy") except: pass import constants import game import data import particles import hiro class Intro(game.Game): pass class Top(game.Game): def handle_events(self, events): # handle our events first, then the childrens. for e in events: if e.type == KEYDOWN: if e.key == K_ESCAPE: #self.check_transition() self.going = False if e.key == K_s: pass pygame.image.save(pygame.display.get_surface(), "eye_stab_screeny_2008_09_10.png") if e.type == QUIT: self.going = False # this handles the childrens events amongst others. game.Game.handle_events(self, events) def load(self): game.Game.load(self) backgroundfn = os.path.join('data', 'gfx', 'cavern1.png') self.background = pygame.image.load(backgroundfn) self.lighting = self.background.copy().convert_alpha() self.hiro = hiro.Hiro() self.hiro.lighting = self.lighting self.hiro.add_small_flare() self.games.append(self.hiro) def update(self, elapsed_time): game.Game.update(self, elapsed_time) def draw(self, screen): #r = screen.fill((255,255,255,255)) r = screen.blit(self.background, (0,0)) self.lighting.fill((0,0,0,255)) rects = game.Game.draw(self, screen) #rects.append(r) r = screen.blit(self.lighting, (0,0)) rects = [r] #rects.append(r) return rects def stop_all(self): for g in self.games: g.stop() def main(): #print "Hello from your game's main()" #print data.load('sample.txt').read() #pygame.mixer.pre_init(44100,-16,2, 1024* 4) #pygame.mixer.pre_init(44100,-16,2, 1024* 4) pygame.init() pygame.fastevent.init() pygame.threads.init(4) pygame.key.set_repeat(500, 30) # start playing intro track, before the screen comes up. if 1: if 1: intro_track = os.path.join("data", "sounds", "intro.ogg") if os.path.exists(intro_track): intro_sound_big = pygame.mixer.Sound(open(intro_track, "rb")) intro_sound_big.play(-1) else: try: intro_track = os.path.join("data", "intro.ogg") pygame.mixer.music.load(intro_track) pygame.mixer.music.play(-1) except: print "failed playing music track: '%s'" % intro_track screen = pygame.display.set_mode(constants.SCREEN_SIZE) top = Top(name = "Exploratio") top.set_main() # Add the intro as a child game.Game to the top game.Game. intro = Intro(name ="Exploratio intro") top.games.append(intro) top.intro = intro if 0: top.particles = particles.Flare() top.games.append(top.particles) top.particles.load_real(direction=-1, pos =(200,200)) import urdpyg.sounds data.sounds = urdpyg.sounds.SoundManager() data.sounds.Load(urdpyg.sounds.SOUND_LIST, os.path.join("data", "sounds")) clock = pygame.time.Clock() clock.tick() while top.going: elapsed_time = clock.get_time() if elapsed_time: elapsed_time = elapsed_time / 1000. # speed up time... #elapsed_time *= 4 events = pygame.fastevent.get() if [e for e in events if e.type == constants.INTRO_FADEOUT]: intro_sound_big.fadeout(1000) # intro_sound_big.stop() # we pass in the events so all of them can get the events. top.handle_events(events) # each part that uses time, for animation or otherwise # gets the same amount of elapsed time. This also reduces the # number of system calls (gettimeofday) to one per frame. top.update(elapsed_time) data.sounds.Update(elapsed_time) # the draw method retunrns a list of rects, # for where the screen needs to be updated. rects = top.draw(screen) # remove empty rects. rects = filter(lambda x: x != [], rects) #rects = filter(lambda x: type(x) not in map(type, [pygame.Rect, [], tuple([1,2])]) , rects) rects = filter(lambda x: type(x) not in map(type, [1]) , rects) # if not empty, then update the display. if rects != []: #print rects pygame.display.update(rects) #pygame.display.update(rects) # we ask the clock to try and stay at a FPS rate( eg 30fps). # It won't get exactly this, but it tries to get close. clock.tick(constants.FPS) #print clock.get_fps() # we try and clean up explicitly, and more nicely... # rather than hoping python will clean up correctly for us. pygame.quit() pygame.threads.quit() exploratio-0.1.1/lib/urdpyg/0000755000175000017500000000000011311214451014414 5ustar renereneexploratio-0.1.1/lib/urdpyg/__init__.py0000644000175000017500000000027211143032667016540 0ustar renerene""" The unstable part of rdpyg. Contains modules that are not very well designed, tested, or commented, and which are not planned to be have the same api stick around for ages. """ exploratio-0.1.1/lib/urdpyg/sounds.py0000644000175000017500000001273011143032667016316 0ustar renerene""" file: sounds.py purpose: to load all the sounds, and manage the playing of them. Probably have different sets of sounds in here somehow. NOTE: not using pygames channel queueing as it only allows one sound to be queued. Also the sound can only be queued on a certain channel. """ import pygame import os import glob import time from pygame.locals import * SOUND_PATH = os.path.join("data", "sounds") def get_sound_list(path = SOUND_PATH): """ gets a list of sound names without thier path, or extension. """ # load a list of sounds without path at the beginning and .ogg at the end. sound_list = map(lambda x:x[len(path)+1:-4], glob.glob(os.path.join(path,"*.ogg")) #glob.glob(os.path.join(path,"*.wav")) ) return sound_list SOUND_LIST = get_sound_list() class SoundManager: """ Controls loading, mixing, and playing the sounds. Having seperate classes allows different groups of sounds to be loaded, and unloaded from memory easily. Useage: sm = SoundManager() sm.Load() """ def __init__(self, sound_list = SOUND_LIST, sound_path = SOUND_PATH): """ """ self.mixer = None self.music = None self.sounds = {} self.chans = {} self._debug_level = 0 self.sound_list = sound_list self.sound_path = sound_path # sounds which are queued to play. self.queued_sounds = [] def _debug(self, x, debug_level = 0): """ """ if self._debug_level > debug_level: print x def Load(self, sound_list = [], sound_path = "."): """Loads sounds.""" sounds = self.sounds if not pygame.mixer: for name in sound_list: sounds[name] = None return for name in sound_list: if not sounds.has_key(name): fullname = os.path.join(sound_path, name+'.ogg') try: sound = pygame.mixer.Sound(open(fullname, "rb")) except: sound = None self._debug("Error loading sound", fullname) sounds[name] = sound def GetSound(self, name): """ Returns a Sound object for the given name. """ if not self.sounds.has_key(name): self.Load([name]) return self.sounds[name] def Stop(self, name): if self.chans.has_key(name): if self.chans[name]: if self.chans[name].get_busy(): self.chans[name].stop() def StopAll(self): """ stops all sounds. """ for name in self.chans.keys(): self.Stop(name) def Play(self, name, volume=[1.0, 1.0], wait = 0, loop = 0): """ Plays the sound with the given name. name - of the sound. volume - left and right. Ranges 0.0 - 1.0 wait - used to control what happens if sound is allready playing: 0 - will not wait if sound playing. play anyway. 1 - if there is a sound of this type playing wait for it. 2 - if there is a sound of this type playing do not play again. loop - number of times to loop. -1 means forever. """ vol_l, vol_r = volume sound = self.GetSound(name) if sound: if wait in [1,2]: if self.chans.has_key(name) and self.chans[name].get_busy(): if wait == 1: # sound is allready playing we wait for it to finish. self.queued_sounds.append((name, volume, wait)) return elif wait == 2: # not going to play sound if playing. return self.chans[name] = sound.play(loop) if not self.chans[name]: if loop == 1: # forces a channel to return. we fade that out, # and enqueue our one. self.chans[name] = pygame.mixer.find_channel(1) #TODO: does this fadeout block? self.chans[name].fadeout(100) self.chans[name].queue(sound) else: # the pygame api doesn't allow you to queue a sound and # tell it to loop. So we hope for the best, and queue # the sound. self.queued_sounds.append((name, volume, wait)) # delete the None channel here. del self.chans[name] elif self.chans[name]: self.chans[name].set_volume(vol_l, vol_r) else: raise 'not found' def Update(self, elapsed_time): """ """ for name in self.chans.keys(): if not self.chans[name]: # it may be a NoneType I think. del self.chans[name] elif not self.chans[name].get_busy(): del self.chans[name] old_queued = self.queued_sounds self.queued_sounds = [] for snd_info in old_queued: self.Play(*snd_info) def PlayMusic(self, musicname): """ Plays a music track. Only one can be played at a time. So if there is one playing, it will be stopped and the new one started. """ music = self.music if not music: return if music.get_busy(): #we really should fade out nicely and #wait for the end music event, for now, CUT music.stop() fullname = os.path.join('sounds', musicname) music.load(fullname) music.play(-1) music.set_volume(1.0) exploratio-0.1.1/lib/urdpyg/map/0000755000175000017500000000000011311214451015171 5ustar renereneexploratio-0.1.1/lib/urdpyg/map/__init__.py0000644000175000017500000000000011143032667017302 0ustar renereneexploratio-0.1.1/lib/urdpyg/map/map.py0000644000175000017500000001241211143032667016332 0ustar renerene""" = Features wanted = * When not moving it can take only update parts of the screen. * update(dirty_rects) can be used to speed up drawing. * by only updating areas which are dirty. * if the map is not moving we can make it lots speedier. * Offscreen buffer. Blit all smaller tiles to an offscreen buffer then blit one big image to the screen. This can be faster on some screens/computers. * Different tile sizes. * different sizes on the same map. * Join maps together easily. * Different drawable sizes. Ie different camera views. * Be able to be used with pygame or pyopengl. * Different camera modes: * jump scrolling, * jump the map in blocks. Like ten pixels at a time. * smooth scrolling, * every pixel the camera moves the tiles move. * smooth-jump scrolling. * Mostly the screen stays still. When the character nears the edge everything stops moving while the maps scrolls over a little way. * centered camera. * Can center the camera on * Looping Map Edges * Paralax scrolling. * Moving layers at different speeds. * Multiple views of the map. * miniview of the map. Perhaps using a scaled version or one pixel per tile. * minimize overdraw. * using dirty rectangles. * for alpha images precalculate 'full rects'. * That is like a bounding box in the middle where the area is full. * think about using a coverage buffer. * animated tiles will probably always need to be redrawn(unless it's the same frame). * Overlapping tiles. * As well as overlapping whole maps. For joining maps together. * Layers/Z ordering. * draw characters by descending y value on same layer. * for certain types of games: see for explanation: * http://www.gamedev.net/reference/programming/features/gpgenesis9/page7.asp * line of sight tests between tiles and pixels/rects. * collision detection between tiles and pixels/rects. * some tiles may be pass through. * tiles on different layers may be collidable, others not. * fog of war. * darkening/lightening of areas. * Rotatable tiles. * scalable tiles? Other transforms needed? * Easy layer toggling. * So eg when you go inside a building the roof comes off and you can see inside. = Implementation ideas = * Use pygame sprites and sprite groups. * could then reuse lots of code... optimize in one place. Speed development. * think of camera movement as simply moving a sprite group in a certain way. * Use a quad tree for the collision detection. * Could use it for moving, and non moving. * Left to right, or top to bottom scrollers can be optimized in different ways. = Some map editors = The tile combie(or engine if you want) should have most of the features that these map editors contain. http://tilestudio.sourceforge.net/ http://www.tilemap.co.uk/ = A discussion about features = background tiling, layers, collision detection between layers and stuff (rect and pixel) paralax scrolling animation of background/sprites line of sight tests between tiles and pixels based on layer compositions and such eek, that's a lot of stuff good stuff :) separate environmental and UI layer systems what do you mean? so you can draw your UI without worrying how height your environments layers are the UI layers are alwayrs on top ah, cool basically, just 2 lists for heights auto-shadowing for sprites is good indeed, that'd be cool doing like angled skews on the images, and drawing them on the ground layer so you dont have to have separate shadow images for them nice or just auto positioning the same image, but based on heigth of the sprite so like a flying ship has its shadow in the real place, and its in its height-adjusted place, like zaxxon which basically just means you have a transformation for height built in, and use a sort of worrld coords and translated drawing coords aah which makes sense so you should have parameters to what your viewing perspective is, so they can adjust it based on how their art is rendered like: 1.5:1.0 or something you could also have layer toggling like i did in VT, where if you go into a building, it switches what the background tiles are. and if you change floors, it also does that ah, that sounds nice too but that may be a bit specific. though, you could make the design so its possible to rotate through BG tile maps specifically, like theyre layered and do a fall through if the current selected one doesnt exist to the default background map, which has all its spaces mapped sorta an "optional current level background" good for things where people take stairs, and you still want the ground of things outside buildings and such im running out of stuff ive thought about for tiling engines hehe. that's all stuff I didn't think about :) i want to retire im pretty happy doing fuck all all the time now heh having layers greyed out would be good hehe. mostly I'm happy doing fuck all too :) optional layers? or you mean something else? """ exploratio-0.1.1/lib/urdpyg/gl_images.py0000644000175000017500000000623111143032667016731 0ustar renerene#file: images.py #purpose: everything to do with image loading. import pygame import os import time from OpenGL.GL import * try: from mygl import * except: pass def load_gl_textureRGB(name, flip = 1, internal_format = GL_RGB): """ returns a texid for the loaded image. """ if type(name) == type(""): im_surf = pygame.image.load(os.path.join("..", "data", "images", name)) else: im_surf = name image = pygame.image.tostring(im_surf, "RGB", flip) image_width = im_surf.get_width() image_height = im_surf.get_height() #TODO: add check for pow2 size. tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, tex) ##glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR) ##glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR) #glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT) #glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT) #glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST) #glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST) glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR) glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR) #glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR) #glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR) #glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP) #glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP) #glEnable(GL_TEXTURE_GEN_S) #glEnable(GL_TEXTURE_GEN_T) glTexImage2D(GL_TEXTURE_2D, 0, internal_format, image_width, image_height, 0, GL_RGB, GL_UNSIGNED_BYTE, image) return tex def load_gl_textureRGBA(name, flip = 1, internal_format = GL_RGBA): if type(name) == type(""): im_surf = pygame.image.load(os.path.join("..", "data", "images", name)) else: im_surf = name image = pygame.image.tostring(im_surf, "RGBA", flip) #print t2 - t1 image_width = im_surf.get_width() image_height = im_surf.get_height() #TODO: add check for pow2 size. tex = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, tex) ##glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR) ##glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR) #glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT) #glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT) #glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST) #glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST) glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR) glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR) #glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR) #glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR) #glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP) #glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_SPHERE_MAP) #glEnable(GL_TEXTURE_GEN_S) #glEnable(GL_TEXTURE_GEN_T) #glTexImage2D(GL_TEXTURE_2D, 0, 3, image_width, image_height, glTexImage2D(GL_TEXTURE_2D, 0, internal_format, image_width, image_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image) return tex exploratio-0.1.1/lib/urdpyg/milk_skeleton.py0000644000175000017500000005570511143032667017654 0ustar renerene""" Copyright (C) 2002 by Rene Dudfield. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. """ import string, sys, os import time import UserDict import Numeric N = Numeric from urdpyg.converters import ms3d_ascii_importer import bisect """ Data flow: -------------- milkshape converter -> MilkshapeModelLoader In the MilkshapeModelLoader it converts the data into its internal representation. """ class MilkshapeModelLoader: """ responsible for loading a milkshape model. """ def __init__(self, file_name = ""): self._debug_level = 0 self._is_tex = 0 if file_name: self.Load(file_name) def _debug(self, x, debug_level = 1): """ """ if self._debug_level > debug_level: print x def IsTextured(self): if self._is_tex: return 1 else: return 0 def Load(self, file_name): """ """ t1 = time.time() self.data = ms3d_ascii_importer.convert_milkshape( file_name ) t2 = time.time() self._debug("load time of milk:%s:" % (t2 - t1), 2) d = self.data["mesh_data"][0] material_index = d["material_index"] self._debug("material_index:%s" % material_index, 2) self.texcoords= Numeric.asarray(d["texcoords"], 'f') self.points = Numeric.asarray(d["points"], 'f') self.normals = Numeric.asarray(d["normals"], 'f') self.indices = Numeric.asarray(d["indices"], 'i') if material_index != -1: m = self.data["materials"][material_index] self._debug("m.material_name:%s" % m.material_name, 2) self._debug("m.diffuse_texture_name:%s" %m.diffuse_texture_name, 2) self._debug("m.alpha_texture_name :%s" %m.alpha_texture_name, 2) self.image_name = apply(os.path.join, os.path.split(m.diffuse_texture_name[2:])) #NOTE: FIXME: materials don't need textures. #NOTE: FIXME: there are different textures too. self._is_tex = 1 #time.sleep(2) else: self._is_tex = 0 self.skeleton = MilkSkeleton(self.data) class BoneHeirarchy: """ Which bones are parents/children of which other bones. - has bone names, and bone indices into AbsoluteBones/RelativeBones. - GetChildren_names/indices - returns a list of names/indices. BoneName2BoneNumber_Map - mapping of bone names to a number in the bone index. """ def __init__(self, milk_bones): """Takes a milk_bones variable from the milkshape converter. """ # given the parents name get back a list of children. self.bone_parents_dict= {} # given the childs name get back a parent. self.bone_children_dict= {} # given a bone name you can get the idx of that bone in the bone list. self.bone_name_to_idx = {} self.Update(milk_bones) def Update(self, milk_bones): """ Takes a milk_bones variable from the milkshape converter. """ #NOTE: if we want to use 1000's bones it may be more efficient to use # ints as the keys. and possibly lists to store them. # # This is an efficient storage for 1000's of skeletons with 1000's of # bones. 1000 * 1000 * 20 == 20 megabytes. # 1000 * 1000 * 4 == 4 megabytes for a list implementation. self.bone_parents_dict= {} self.bone_children_dict= {} self.bone_name_to_idx = {} # keyed by bone name, valued by milk_bones instances. self.bone_dict = {} for b in milk_bones: if not self.bone_parents_dict.has_key(b.parent_name): self.bone_parents_dict[b.parent_name] = [b.name] else: self.bone_parents_dict[b.parent_name].append(b.name) if not self.bone_children_dict.has_key(b.name): self.bone_children_dict[b.name] = [b.parent_name] else: self.bone_children_dict[b.name].append(b.parent_name) #assert( not self.bone_dict.has_key(b.name) ) self.bone_dict[b.name] = b self.bone_name_to_idx = self._make__bone_name_to_idx(milk_bones) def _make__bone_name_to_idx(self, milk_bones): """ returns a dict mapping bone name -> its idx within the list. """ bone_name_to_idx = {} for idx, milk_bone in zip(range(len(milk_bones)), milk_bones): if bone_name_to_idx.has_key(milk_bone.name): raise ValueError("bone allready exists with name, %s" % milk_bone.name) bone_name_to_idx[milk_bone.name] = idx return bone_name_to_idx def GetChildren_idx(self, bone_name): """ returns a list of idx for the children of given bone name. """ children = self.GetChildren(bone_name) idx_list = [] for child in children: idx_list.append(self.bone_name_to_idx[child.name]) return idx_list def GetChildren(self, bone_name): """ Returns a list of children milk_bone instances.""" if not self.bone_parents_dict.has_key( bone_name ): return [] return map(self.bone_dict.get, self.bone_parents_dict[ bone_name ]) #return self.bone_dict[ self.bone_parents[ bone_name ] ] def GetParents(self, bone_name): """ Returns a list of parents milk_bone instances.""" if not self.bone_children_dict.has_key( bone_name ): return [] return map(self.bone_dict.get, self.bone_children_dict[ bone_name ]) #return self.bone_children[ bone_name ] def GetRootName(self): """ Returns the root bones name. """ return self.bone_parents_dict[""][0] def __str__(self): return self.PrintTree(details = 1) def PrintTree(self, a_bone = "ROOT", indent_level = 0, details = 0): """ Returns a string representation of bones tree. a_bone - a milk_bone instance, or "ROOT". if "ROOT" then we return from the root of the tree. """ if a_bone == "ROOT": a_bone = self.bone_dict[self.GetRootName()] return_text_list = [] indent_text = indent_level * " " if details: bone_text = str(a_bone) bone_text.split("\n") a = "".join(map(lambda x,y = indent_text: "".join((y,x,"\n")), bone_text.split("\n"))) return_text_list.append( a ) else: return_text_list.append( indent_text + a_bone.name ) children = self.GetChildren(a_bone.name) for bone in children: child_text = self.PrintTree(bone, indent_level+2, details) return_text_list.append(child_text) return string.join( return_text_list, "\n") class BoneName2BoneNumber_Map(UserDict.UserDict): """ mapping of bone names to a number in the bone index. """ def __init__(self, milk_bones): UserDict.UserDict.__init__(self) self.Update(milk_bones) def Update(self, milk_bones): for b in zip( milk_bones, range(len(milk_bones)) ) : self.data[b[0].name] = b[1] class Bone2Vert_Map(UserDict.UserDict): """ a list of indices for the verts that each bone should transform. Should probably be a Numeric 3d array. where self.data[0] == list of vert indices for the first bone. Each index could be 4 bytes for four bones. - this would be harder to access. - would limit the total number of bones. For now keep it simple. """ def __init__(self, milk_data): self.Update(self, milk_data) def Update(self, milk_data): """ """ # note: milkshape can only have one bone per vert. data = milk_data["mesh_data"]["bone_indices"] #self.data = Numeric.reshape(data, (len(data), 1)) bone2vert_map = {} for bone_idx, vert_idx in zip(data, len(data)): # if not bone2vert_map.has_key(bone_idx): bone2vert_map[bone_idx] = [vert_idx] else: bone2vert_map[bone_idx].append(vert_idx) # class Vert2Bone_Map: def __init__(self, ): self.Update(self, milk_data) def Update(self, milk_data): """ """ # note: milkshape can only have one bone per vert. data = Numeric.array(milk_data["mesh_data"]["bone_indices"], 'i') self.data = Numeric.reshape(data, (len(data), 1)) class Time2Keyframe_Map: """ Each bone should be able to have it's own key frames. time2keyframe_maps[bone_name] -> time2keyframe_map time2keyframe_map[seconds_since_start_of_animation] -> keyframe index's. Depending on whether we want the animation to loop or stop at the start or the end, we return a keyframe on either side of the time specified. TODO: we can loop at the start of the keyframes as well as at the end. """ def __init__(self, loop = 0): """ loop - should we loop the animation back to the start once the last keyframe has been reached? """ self.loop = loop def UpdateFromBones(self, milk_bone): """ milk_bone - used to get the different times for the keyframes. """ times = [] map(lambda x, t = times: t.append(x[0]), milk_bone.positions) self.times = times self.Update(times) def Update(self, times): """ times - a sequence of floats representing keyframes. """ self.times = times # Should the internal format be a dict and a list? # yes, as we need to find the next, and previous, as well as by a number. # should we have seperate keyframes for rotations, translations, # and scaling? # Why not? We do not have support for it in any editor. # not immediately useful. # For now we will just use the times for rotations. #TODO: incomplete. #raise NotImplementedError # the times should be sorted. self.time_index = {} # make an index of times. for t, i in zip(times, range(len(times))): self.time_index[t] = i def GetIndicesEitherSideOfTime(self, time): """ time - a float Returns the two keyframe indices either side of the time given. """ # no looping. # Find the smallest time which is greater than the time given. # TODO: need to do better than a linear search. # the code below is incomplete, needs fixing. raise "incomplete" largest_num = len(self.times) - 1 if time == self.times[smaller_index]: greater_index = 0 smaller_index = bisect.bisect_left(self.times, time) # if the position is greater than or equal to the largest index, # then we return the largest num as both of them. if smaller_index >= largest_num: smaller_index = largest_num greater_index = largest_num else: greater_index = smaller + 1 if greater_index > largest_num: greater_index = largest_num class AbsoluteBones: """ Stores the absolute transforms. There is a seperate one of these for each keyframe. - Need matrix, and quat+pos_vector versions - The matrix versions would be used to transform verts. - The quat_pos_vector versions will blend with other bones. - The conversion to matrices will need to be cached. - Use three arrays. - rotation quats( an array of 'four elements' ). - translation quats(array of 'four elements' ). Maybe only need matrix version for absolute? - No, need to slerp between two absolute bones. Don't need a matrix representation? - maybe not, if the these are only used to slerp up an intermediate set of bones. NOTE: for transforming the verts, it will be faster to transform them with a 3x3 rotation matrix if there is no translation/scaling happening. """ class RelativeBones: """ Stores transforms relative to it's parent. There is a seperate set of these for each of the keyframes. - Need matrix, and quat+pos_vector versions - The matrix versions would be used to transform verts. - The quat_pos_vector versions will blend with other bones. - The conversion to matrices will need to be cached. - Use three arrays. - rotation quats( an array of 'four elements' ). - translation quats(array of 'four elements' ). TODO: find if a quatRotation * quatTranslation is equal to a matrixRotation * matrixTranslation. """ def Update(self, milk_bone): """ From the milkshape data transform it into an internal representation. milk_bone - a bone from the converter. - Convert the Euler angle milkshape rotations into quaternions. - Convert the milkshape positions into quaternions. Q(Px, Py, Pz, w =0.0) - rotation, position quaternions multiplied and stored. """ # mb = milk_bone mb.position mb.position_keys mb.rotation mb.rotation_keys class MilkSkeleton: """ ---------------------------------------------------------------------- Data structures. - '=' denotes data belongs to this parent. Skeleton - this is where everything is put together. - we may want to share some data between skeletons, so we may need a higher level system. - this higher level system would share the different parts of memory. - Maybe it could even transform all of the data at once. = BoneHeirachy DONE. = Keyframes = Bone2Vert_Map DONE. = Time2Keyframe_Map = KeyframeNumber2Time_Map Keyframes - collects the different keyframe data for a skeleton. = AbsoluteBones = RelativeBones = Time2Keyframe_Map = KeyframeNumber2Time_Map AbsoluteBones - bones represented in their absolute form. - Need matrix, and quat+pos_vector versions - The matrix versions would be used to transform verts. - The quat_pos_vector versions will blend with other bones. - The conversion to matrices will need to be cached. - Use three arrays. - rotation quats( an array of 'four elements' ). - translation quats(array of 'four elements' ). - transform matrices(array of '16 elements' ie 4x4 matrices). RelativeBones - these bones will have all relative data. Eg each bone will only be relative to the others. Time2Keyframe_Map. - gets two keyframes on either side of a given time. - this would be per bone? Not at the moment(it should be per skeleton). KeyframeNumber2Time_Map. - given a keyframe number, give the time for it. - this would be per bone? Not at the moment(it should be per skeleton). DONE. BoneHeirachy - which bones are parents/children of which other bones. - has bone names, and bone indices into AbsoluteBones/RelativeBones. - GetChildren_names/indices - returns a list of names/indices. BoneName2BoneNumber_Map - mapping of bone names to a number in the bone index. DONE. Bone2Vert_Map - a list of indices for the verts that each bone should transform. Vert2Bone_Map - vert to list of bones which effect them. MilkBones - this is the data from the milk format. This contains the positions, and rotations in euler format, and the keyframe times. local2world_transform - a transform specifying where in the world the skeleton is. - This will likely change occasionally. - from every frame to once every minute. - is this specified by the root node? - Could we add this as the new root node? - would simplify the code if we did. - Can be added as an after thought if needed. Pretty easy. - Not really, as it possible this would change all the time. - We may want to add this, as it will solve having to re-transform them. - On the other hand this could be done in hardware with gf+ cards. ---------------------------------------------------------------------- --------------------------------------------------------------------- Order of the operations. - Things that need to be done in order to get the model transformed. Set up stuff. - things to do around load time. From the milk bones set up: - BoneHeirachy - Set up the relative bones. - Convert the Euler angle milkshape rotations into quaternions. - Convert the milkshape positions into quaternions. Q(Px, Py, Pz, w =0.0) - rotation, position quaternions multiplied and stored. - Time2Keyframe_Map - KeyframeNumber2Time_Map AbsoluteBones are made from RelativeBones. For each keyframe. Multiply the bones down the heirarchy. child.absolute = parent.absolute * child.relative Per frame stuff. Get current time in animation. From Time2Keyframe_Map grab two keyframes on either side of current time. For every absolute quat: Interpolate between two keyframes: t1 = current_time_in_animation - kf_a.time t2 = kf_b.time -kf_a.time slerp = t1/t2 frame_now = quat_slerp(kf_a.absolute, kf_b.absolute, slerp) Generate the matrices for each absolute quat. Transform each absolute matrix by the local2world_transform. Transform verts of the mesh: For vertex which is affected by one bone: For each absolute matrix transform its verts. If the vert is only affected by one bone: Multiply the vert by the absolute matrix. else: somehow interpolate the different bones. - TODO: ^ - maybe this could be done in the slerp? - storing some extra absolute quats for the verts affected by multiple ones. - this is where bone weights can fit in. For now we will only support one bone per vertex. Alternate way to transform the skin: For each vertex: look at the weight structure. ulong32 boneIndices - 4 indices to bones. ulong32 weights - 4 weights. --------------------------------------------------------------------- Optimizations. --------------------------------------------------------------------- When a key frame does not have any translations the transform of the vertices can be optimized to only use a 3x3 rot, instead of a 4x4. - There may be other optimizations depending on the bones state. - Maybe we could store a BONE_STATE int which will allow us to quickly identify a type of bone? This would allow us to quickly see if the bone has no translation. - We could group bones of similar nature together to make the transforms quicker. Eg all bones with no translation part could be stuck together. - Remember that we need to apply a local2world transform to all of the different absolute matrices. We may be able to cache certain different transforms. - I'm pretty sure there will be many repeated transforms. A cheap way to interpolate between keyframes would be linear using the mesh's verts. This would involve calculating the mesh for each key frame, and then interpolating between each vertex in meshes a, and b. Perhaps this could be an optional thing. To be used for slow computers, when a character is far away, or when the difference in time or movement of the character is really small. A downside to this is that you need to keep at least three sets of the mesh around at any time. An upside to this is that interpolation can be done on lighting values too. --------------------------------------------------------------------- --------------------------------------------------------------------- TODOS: Future todos: - have keyframe data for seperate parts of the skeleton. - eg make the hand have it's own keyframes. - This would complicate how to construct the absolute quats. - You would recalculate down from the animation for that part. - so if the arm was using some extra ones we'd go from there. - Probably not so useful until the animation tool supports it. - Incorporate bone weights into it. - Milkshape doesn't support these, however others(characterfx) do. - Look at the different ways to accelerate these with hardware. - ati, and nvidia have things to do this from geforce up. --------------------------------------------------------------------- --------------------------------------------------------------------- Dependencies - a list of different dependencies that need to be considered. - helps with caching different things. --------------------------------------------------------------------- --------------------------------------------------------------------- OLD Order of the operations. X Convert the axis angle milkshape rotations into quaternions. X The translations should also be converted into quaternions, X and multiplied by the rotation part. Q(Px, Py, Pz, w =0.0) X Have an absolute quaternion, and a relative one for each bone. X Quats should be seperate for the current frame that is to be rendered. X - that is the final bones for the current frame should be in a single X array. X - this is so that they may be easily converted to matrices. X Absolute matrices for the current frame should be made. X - these matrices include For each keyframe. Multiply the bones down the heirarchy. child.absolute = parent.absolute * child.relative To interpolate between two keyframes we do: t1 = current_time_in_animation - keyframe_a.time t2 = keyframe_b.time -keyframe_a.time slerp = t1/t2 frame_now = quat_slerp(keyframe_a.absolute, keyframe_b.absolute, slerp) Any time a bones rotation changes we need to recalculate all of its children. To transform verts of the mesh: We need the absolute matricies for each bone. Do we support multiple bones per vertex? If so will we use weighting? Apply a local2world transform to all of the different absolute matrices. - this should be added as a new root node. """ def __init__(self, milk_data): """ the data attribute from the milkshape converter. """ milk_bones = milk_data['bones'] self.milk_bones = milk_bones self.bone_heirarchy = BoneHeirarchy(milk_bones) self.bone_name2bone_number_map = BoneName2BoneNumber_Map(milk_bones) # for each bone we need: # - rotations. # - positions. # - scales. # - keyframe number -> time map. # - Way to get the two keyframes on either side of a given time. # these are 4 element quats. #self.rotations = N.array() # these are 3 element positions. #self.positions = N.array() def _convert_angles_to_quats(self): """ This converts the different rotations of the bones into quaternions. """ exploratio-0.1.1/lib/urdpyg/some_sound.py0000644000175000017500000000633211143032667017157 0ustar renerene""" file: some_sound.py purpose: to load all the sounds, and manage the playing of them. Probably have different sets of sounds in here somehow. """ import pygame import os import glob from pygame.locals import * def get_sound_list(): """ """ # load a list of sounds without sound/ at the beginning and .wav at the end. sound_list = map(lambda x:x[7:-4], glob.glob(os.path.join("sounds","*.wav")) ) ogg_sound_list = map(lambda x:x[7:-4], glob.glob(os.path.join("sounds","*.ogg")) ) sound_list.extend(ogg_sound_list) return sound_list class SoundManager: """ Controls loading, mixing, and playing the sounds. Having seperate classes allows different groups of sounds to be loaded, and unloaded from memory easily. """ def __init__(self): """ """ self.mixer = None self.music = None self.sounds = {} self.chans = {} self.initialized = 0 self._debug_level = 1 def _debug(self, x, debug_level = 0): """ """ if self._debug_level > debug_level: print x def Initialize(self): """ Initializes the mixer. """ global mixer, music try: import pygame.mixer pygame.mixer.init(44000, 8, 0) mixer = pygame.mixer music = pygame.mixer.music self.initialized = 1 return 1 except (ImportError, pygame.error): self.initialized= 0 self._debug("Error initializing sound.") return 0 def Load(self, names = sound_list): """Loads sounds.""" sounds = self.sounds if not mixer: for name in names: sounds[name] = None return for name in names: if not sounds.has_key(name): fullname = os.path.join('sounds', name+'.wav') try: sound = mixer.Sound(fullname) except: sound = None self._debug("Error loading sound") sounds[name] = sound def GetSound(self, name): """ Returns a Sound object for the given name. """ if not self.sounds.has_key(name): self.Load([name]) return self.sounds[name] def Play(self, name, volume=[1.0, 1.0], wait = 1): """ Plays the sound with the given name. name - of the sound. volume - left and right. Ranges 0.0 - 1.0 wait - if there is a sound of this type playing wait for it. """ vol_l, vol_r = volume sound = self.GetSound(name) if sound: if self.chans.has_key(name): c = 0 while self.chans[name].get_busy(): time.sleep(0.001) c += 1 if c > 40: break self.chans[name] = sound.play() if not self.chans[name]: self.chans[name] = pygame.mixer.find_channel(1) self.chans[name].play(sound) if self.chans[name]: self.chans[name].set_volume(vol_l, vol_r) del self.chans[name] def PlayMusic(self, musicname): """ Plays a music track. Only one can be played at a time. So if there is one playing, it will be stopped and the new one started. """ music = self.music if not music: return if music.get_busy(): #we really should fade out nicely and #wait for the end music event, for now, CUT music.stop() fullname = os.path.join('sounds', musicname) music.load(fullname) music.play(-1) music.set_volume(1.0) exploratio-0.1.1/lib/urdpyg/milkviewer4.py0000644000175000017500000000422311143032667017243 0ustar renerene import pygame from OpenGL.GL import * from numeric_gl import * from urdpyg.converters import ms3d_ascii_importer from urdpyg.milk_skeleton import * from urdpyg import gl_images class MilkshapeModel(MilkshapeModelLoader): """ Loads and displays a milk shape 3d model. """ def Load(self, file_name): MilkshapeModelLoader.Load(self, file_name) if self.IsTextured(): self.LoadImage(self.image_name) def LoadImage(self, filename): im_surf = pygame.image.load(filename) self.tex = gl_images.load_gl_textureRGB(im_surf) def ReloadTextures(self): """ reloads any textures. Useful when a context change happens. """ # NOTE: Shouldn't delete the texture... I think. if self.IsTextured(): self.LoadImage(self.image_name) def Display(self): """ Call this to draw. """ # set up the correct model matrix. self._StartDisplay() self._MiddleDisplay() self._FinishDisplay() def _MiddleDisplay(self): glDrawElementsui(GL_TRIANGLES, self.indices) def _StartDisplay(self): """ This is all the stuff you call before drawing. """ # bind the correct texture/s # enable the arrays for drawing. # draw the arrays. #print "points", self.points #print "texcoords", self.texcoords #print "indices", self.indices if self.IsTextured(): glEnable(GL_TEXTURE_2D) # Enables depth testing. glEnable(GL_DEPTH_TEST) # Enables smooth shading. glShadeModel(GL_SMOOTH) if self.IsTextured(): glBindTexture(GL_TEXTURE_2D, self.tex) glEnableClientState(GL_VERTEX_ARRAY) if self.IsTextured(): self._debug("is tex",4) glEnableClientState(GL_TEXTURE_COORD_ARRAY) glVertexPointer(3, GL_FLOAT, 0, self.points) if self.IsTextured(): glTexCoordPointer(2, GL_FLOAT, 0, self.texcoords) def _FinishDisplay(self): """ Call after drawing. """ glDisableClientState(GL_VERTEX_ARRAY) if self.IsTextured(): glDisableClientState(GL_TEXTURE_COORD_ARRAY) glDisable(GL_DEPTH_TEST) if self.IsTextured(): glDisable(GL_TEXTURE_2D) exploratio-0.1.1/lib/urdpyg/some_sprites.py0000644000175000017500000003266611143032667017531 0ustar renerene""" file: some_sprites.py purpose: animation, sprite playing. """ import os, os.path, glob, sys, bisect import time import pygame #import pygame.transform from pygame.locals import * DEBUG = 0 SCREENRECT = Rect(0, 0, 640, 480) try: import use_gl USE_GL = use_gl.USE_GL print "ahasjdhasjkhkjhsfd" except: USE_GL = 0 print USE_GL if USE_GL: from spritegl import SpriteGL, GroupGL pygame.sprite.Sprite = SpriteGL pygame.sprite.Group = GroupGL pygame.sprite.RenderPlain = GroupGL pygame.sprite.RenderUpdates = GroupGL #layer_order = ["walk_forwards", # "walk_left", # "walk_right", # "red background", # "transparent background"] """ layer_order = ["bam", "yellow", "red", "orange" ] """ # animations are made out of different frames from the character anim. # they have a list of frames, and a length of time for each frame. #animations = {} #a = animations #a['walk'] = [("walk_forwards", 1.0 ), # ("walk_right", 1.0), # ("walk_forwards", 1.0), # ("walk_left", 1.0), # ("walk_forwards", 1.0), # ] """ a['bam'] = [ ("orange", 0.01 ), ("red", 0.01), ("yellow", 0.01), ("orange", 0.01 ), ("red", 0.01), ("yellow", 0.01), ("orange", 0.01 ), ("red", 0.01), ("yellow", 0.01), ("bam", 0.4), ] """ def get_background_names(base_dir): """ TODO: needs fixing/testing. """ background_names = map(lambda x:x[len("background")+1:-4], glob.glob(os.path.join(base_dir, "background", "*.png")) ) background_names.extend( map(lambda x:x[len("background")+1:-4], glob.glob(os.path.join(base_dir, "background", "*.jpg")) ) ) return background_names class Timer: def __init__(self, length): """ a = Timer(10) # if the timer is finished. if a: print "asdf" """ self.Start(length) def Start(self, length): """ length is the amount of time that this timer should go for. """ self.end_time = time.time() + length def __nonzero__(self): if time.time() > self.end_time: return 1 else: return 0 def animation_factory(anim_data, loop = 1): """ Returns a dict keyed by anim_name valued by Animation instances. anim_data - keyed by anim name, valued by a list of tuples(frame_name, length). loop - passed through to Animation class. """ anims = {} for anim_name in anim_data.keys(): anims[anim_name] = Animation(anim_data[anim_name], anim_name, loop) return anims class Animation: """ For telling which of the frames should be drawn. Howto use: a = Animation(...) a.Start() if a.StillGoing(): new_frame_to_draw = a.NewFrame() if new_frame_to_draw: draw(new_frame_to_draw) else: # old frame to be rendered. pass else: # figure out what to do at end of anim. pass """ def __init__(self, animation_data, name, loop = 1): """ animation_data - a list of tuples (frame_name, time). The time part says for how long in the animation that the frame should be shown. Must have at least one element. loop - should the animation loop. If 0 the animation will return the last frame when it gets to the end. If -1 the animation will loop for ever. If non zero the animation will loop that many times. """ assert(len(animation_data) > 0) self.animation_data = animation_data self.loop = loop self.name = name self.Start() self.SetUpAnimationData(animation_data) self.last_frame = "" def Start(self, loop = 1): """ Starts the animation at the beginning. """ self.loop = loop self.start_time = time.time() self.last_frame = "" def GetName(self): return self.name def NewFrame(self): """ Returns the frame name if there is a new frame needed for the animation. Otherwise returns 0. """ frame_name = self.StillGoing() if frame_name == self.last_frame: return 0 else: return frame_name def StillGoing(self): """ returns the frame name if still going else, returns 0 if finished. """ # Add up the total length of the anim. cur_time = time.time() since_beginning = cur_time - self.start_time # do the infinity loop. if self.loop == -1: time_in_anim = since_beginning % self.GetLengthOfAnim() # no looping of anim. elif self.loop == 0: if since_beginning > self.GetLengthOfAnim(): # we are finished, so we return 0. return 0 else: time_in_anim = since_beginning # we are set to play a specific number of times. else: if since_beginning > self.loop * self.GetLengthOfAnim(): # we are finished, so we return 0. return 0 # find out where we are in the animation. time_in_anim = since_beginning % self.GetLengthOfAnim() # figure out which frame we are at. frame_name = self._GetFrameGivenTimeInAnim(time_in_anim) return frame_name def SetUpAnimationData(self, animation_data): """ Sets up the animation data ready for processing. """ self.anim_length_once = reduce(lambda x,y: x+y, map(lambda x:x[1],self.animation_data )) # set up the animation data for easy bisecting. # make a list of the animation data that holds the time that the frame starts. self.absolute_anim_data = [] total_time = 0. for frame_name, frame_length in self.animation_data: total_time += frame_length self.absolute_anim_data.append( total_time ) def _GetFrameGivenTimeInAnim(self, time_in_anim): """ Returns the frame name we should be rendering given a time in the anim. """ where_in = bisect.bisect(self.absolute_anim_data, time_in_anim) if where_in < 0: return self.animation_data[0][0] return self.animation_data[where_in][0] def GetLengthOfAnim(self): return self.anim_length_once def GetNumTimesPlayed(self): """ Returns the number of times the animation has been played. """ cur_time = time.time() return int( divmod(cur_time - self.start_time, self.anim_length_once)[0] ) def A__nonzero__(self): """ Used to see if the animation is still going. """ raise "Not implemented" def get_character_frame_names(the_layer_order, base_dir = ".."): """ returns a dict keyed by character name, valued by a dict(keyed by meaningful name, valued by image path name). """ global DEBUG character_names = filter(lambda x: os.path.isdir(os.path.join(base_dir, "characters",x)) , os.listdir(os.path.join(base_dir, 'characters'))) #print character_names character_frame_names = {} for character_name in character_names: t = glob.glob(os.path.join(base_dir, "characters", character_name, "*.gif")) t.extend( glob.glob(os.path.join(base_dir, "characters", character_name, "*.png")) ) # sort them so that they are in numerical order. # the naming scheme of gimp allows this with the normal sort func. t.sort() t.reverse() # now map the gimp file names with the meaningful names. if len(t) != len(the_layer_order): if DEBUG: print "don't have the correct number of frames for character:%s" % (character_name) print t print the_layer_order r = {} for meaning, img_path in zip(the_layer_order, t): r[meaning] = img_path character_frame_names[character_name] = r return character_frame_names def read_anim_data(character_name, base_dir = ".."): """ Reads the animation data from the characters anim.py file. """ d = {} e = {} file_name = os.path.join(base_dir, "characters",character_name , "anim.py") contents = open(file_name).read() a = compile(contents, file_name, "exec") eval(a, e, e) return [e['animations'], e['layer_order']] image_cache = {} def load_image(name, colorkey=None, convert_alpha = 0): global image_cache if image_cache.has_key(name): return [image_cache[name][0], pygame.Rect(image_cache[name][1])] try: image = pygame.image.load(name) except pygame.error, message: print 'Cannot load image:', name raise SystemExit, message if convert_alpha: image = image.convert_alpha() else: image = image.convert() if colorkey is not None: if colorkey is -1: colorkey = image.get_at((0,0)) image.set_colorkey(colorkey, RLEACCEL) image_cache[name] = (image, image.get_rect()) return image_cache[name] class A(pygame.sprite.Sprite): def __init__(self, im_name): pygame.sprite.Sprite.__init__(self) #call Sprite initializer self.image, self.rect = load_image(im_name, -1) class ImageAnimation(pygame.sprite.Sprite): def __init__(self, animation_set_name, initial_animation): """ animation_name - name of the animation set to use. """ pygame.sprite.Sprite.__init__(self) #call Sprite initializer self.animation_set_name = animation_set_name self.current_animation = initial_animation self.position = (0,0) # make self.layer_order, and self.animations self.LoadAnimationData() #character_image_dict - this is a dict keyed by # meaningful name, valued by image path name. self.character_image_dict = get_character_frame_names(self.layer_order)[animation_set_name] # load the images. self.images = {} self.LoadImages() # Make a whole heap of animation classes. self.anims = animation_factory(self.animations, loop = -1) self.StartAnim(self.current_animation) # modified_images is a dict keyed by modified type valued by # a dict of images of the frames. self.modified_images = {} self.modified_images['originals'] = self.images def StartAnim(self, anim_name, loop = 1): self.current_animation = anim_name self.anims[self.current_animation].Start(loop) new_frame_to_draw = self.anims[self.current_animation].NewFrame() if not new_frame_to_draw: raise "should be a frame here" self.image, self.rect = self.images[new_frame_to_draw] self.rect[0] = self.position[0] self.rect[1] = self.position[1] self.current_frame_name = new_frame_to_draw def SetPosition(self, position): self.position = position self.rect[0] = position[0] self.rect[1] = position[1] #print self.rect def MakeScaledVersion(self, key_name, size): """ keyname - what the scaled version should be called. eg ('really small', (0,0)) size - x,y tuple. """ self.modified_images[key_name] = {} mi = self.modified_images[key_name] for frame_name, image_rect in self.modified_images['originals'].items(): image = pygame.transform.scale(image_rect[0], size) #TODO: probably need to change the size of the rect here. r = (image_rect[1][0], image_rect[1][1], size[0], size[1]) new_rect = pygame.Rect(r) mi[frame_name] = [image, new_rect] def LoadImages(self, image_dict = {}): """ image_dict - should be a dictionary which is keyed by the frame name, and valued by an image for that frame. If the dict is {} then the images are loaded from disk. """ if image_dict == {}: for x in self.character_image_dict.keys(): self.images[x] = load_image(self.character_image_dict[x], -1, 1) else: self.images = image_dict def LoadAnimationData(self): """ """ #get_animations, get_layer_order = read_anim_data(self.animation_name) animations, layer_order = read_anim_data(self.animation_set_name) self.animations = animations self.layer_order = layer_order def move(self, direction): self.position += direction self.rect.move_ip(direction, 0) #self.rect = self.rect.clamp(SCREENRECT) def ResetImageRect(self): """ After changing the self.images dict this should be called. """ self.image, self.rect = self.images[self.current_frame_name] self.rect[0] = self.position[0] self.rect[1] = self.position[1] def SetLogicalImages(self, x_y): """ Sets the appropriate images for the place on the logical grid. """ self.images = self.modified_images[("scaled", x_y)] self.ResetImageRect() def update(self, frame_name =None, percent_trans = None): #def update(self ): """ frame_name - this is the name of the frame to draw. percent_trans - is the alpha value for which to draw If frame_name, and percent_trans are None then they are worked out for themselves. """ if frame_name != None and percent_trans != None: pass if self.anims[self.current_animation].StillGoing(): new_frame_to_draw = self.anims[self.current_animation].NewFrame() if new_frame_to_draw: self.current_frame_name = new_frame_to_draw self.image, self.rect = self.images[new_frame_to_draw] self.rect[0] = self.position[0] self.rect[1] = self.position[1] self.anims[self.current_animation].last_frame = new_frame_to_draw else: # old frame to be rendered. pass else: # figure out what to do at end of anim. pass exploratio-0.1.1/lib/urdpyg/converters/0000755000175000017500000000000011311214451016606 5ustar renereneexploratio-0.1.1/lib/urdpyg/converters/__init__.py0000644000175000017500000000000011143032667020717 0ustar renereneexploratio-0.1.1/lib/urdpyg/converters/cal3d_exporter.py0000644000175000017500000001236511143032667022117 0ustar renerene from math import cos, sin import os, sys, time import quaternion import py3d.milk_skeleton def strl(a_list): """ makes each element in a list a string. """ return map(str, a_list) def ms3d_euler__to__cal3d_quat(x,y,z): """ returns a quat suitable for cal3d ie a list [x,y,z,w]. """ r_quaternion = [0,0,0,0] cosx = cos(x * 0.5) cosy = cos(y * 0.5) cosz = cos(z * 0.5) sinx = sin(x * 0.5) siny = sin(y * 0.5) sinz = sin(z * 0.5) cosc = cosx * cosz; coss = cosx * sinz; sinc = sinx * cosz; sins = sinx * sinz; r_quaternion[0] = (cosy * sinc) - (siny * coss) r_quaternion[1] = (cosy * sins) + (siny * cosc) r_quaternion[2] = (cosy * coss) - (siny * sinc) # why do we have to negate this??? # hmmm ... "milkshape style"... well it works this way =) r_quaternion[3] = -((cosy * cosc) + (siny * sins)) return r_quaternion def test_some_shit(): a_milk_rotation = [-0.00014899999999999999, -0.046429999999999999, -0.017059000000000001] q = ms3d_euler__to__cal3d_quat(*a_milk_rotation) print "w,x,y,z",q q2 = quaternion.fromEuler(*a_milk_rotation) print "x,y,z,w", q2.internal milk_as_angles = map(quaternion.radians_to_angle, a_milk_rotation) q3 = ms3d_euler__to__cal3d_quat(*milk_as_angles) print "x,y,z,w",q3 q_forquat = [q[1], q[2], q[3], q[0]] q3_forquat = [q3[1], q3[2], q3[3], q3[0]] q4 = quaternion.Quaternion(q_forquat) q5 = quaternion.Quaternion(q3_forquat) print q4.internal print "q2", q2.AXYZ() print "q4", q4.AXYZ() print "q5", q5.AXYZ() # Conclusion. What the fuck!?!?? weirdro quaternions. # Going to need to test somewhat. class Cal3dBone: """ a class representing a cal3d bone. """ def __init__(self): """ """ self.bone_id = 0 self.name = "initial_bone_name" self.translation = [-14440., -14440., -14440.] # rotation is a quaternion. self.rotation = [-24440., -24440.,-24440., -24441.] self.local_translation = [-34440., -34440., -34440.] # local rotation is a quaternion. self.local_rotation = [-44440., -44440.,-44440., -44441.] # an index into which bone is the parent. # -1 means there is no parent to this self.parent_id = -54441 # a list of child ids for this bone. They are ints. self.child_ids = [] def to_xml(self, indentation=4): """ returns a string of xml representing this bone. """ indent_text = indentation * " " start_bone = """"""%(self.bone_id, self.name, len(self.child_ids)) start_bone = indent_text + start_bone trans = "%s" % (" ".join( strl(self.translation) )) rot = "%s" % (" ".join( strl(self.rotation) )) local_trans = "%s" % (" ".join( strl(self.local_translation) )) local_rot = "%s" % (" ".join( strl(self.local_rotation) )) parent_id = "%s" % (self.parent_id) child_ids = map(lambda x:"%s" %x, self.child_ids) bits = [trans, rot, local_trans, local_rot, parent_id] bits.extend(child_ids) print bits bits_text = "\n".join(map(lambda x: indent_text*2 + x, bits)) end_bone = indent_text + "" return "\n".join([start_bone, bits_text, end_bone]) class Cal3dSkeleton: def __init__(self): self.bones = [] def to_xml(self, indentation=0): """ returns a string with the xml for the cal3d skeleton. """ indent = indentation * " " start_skeleton = indent + """""" % len(self.bones) bones = "\n".join( map(lambda x: x.to_xml(), self.bones) ) end_skeleton = indent + "" return "\n".join([start_skeleton, bones, end_skeleton]) def read_milk( file_name ): import ms3d_ascii_importer data = ms3d_ascii_importer.convert_milkshape( file_name ) #print dir(data['bones'][0]) cal3d_skeleton = Cal3dSkeleton() bone_heirarchy = py3d.milk_skeleton.BoneHeirarchy(data['bones']) for milk_bone in data['bones']: cb = Cal3dBone() cb.name = milk_bone.name cb.bone_id = bone_heirarchy.bone_name_to_idx[milk_bone.name] cb.child_ids = bone_heirarchy.GetChildren_idx(milk_bone.name) if not bone_heirarchy.bone_name_to_idx.has_key( milk_bone.parent_name ): print "milk_bone.parent_name :%s:" % milk_bone.parent_name if milk_bone.parent_name == "": # has no parent. cb.parent_id = -1 else: cb.parent_id = bone_heirarchy.bone_name_to_idx[milk_bone.parent_name] cal3d_skeleton.bones.append(cb) print cal3d_skeleton.to_xml() if __name__ == "__main__": read_milk(sys.argv[1]) #test_some_shit() exploratio-0.1.1/lib/urdpyg/converters/test_md2_importer.py0000644000175000017500000000101011143032667022624 0ustar renerene""" unit tests for the md2 importer. """ import unittest import md2_importer import os import pprint class TestMd2Importer(unittest.TestCase): pass def testReadHeader(self): """ """ md2_file_name = os.path.join("..", "models", "tris.md2") md2_texture_file_name = os.path.join("..", "models", "hobgoblin.bmp") md2 = md2_importer.Md2Model(md2_file_name, md2_texture_file_name) md2._ReadHeader() pprint.pprint (md2.header) md2.Load() if __name__ == "__main__": unittest.main() exploratio-0.1.1/lib/urdpyg/converters/ms3d_ascii_exporter.py0000644000175000017500000000214211143032667023137 0ustar renerenefrom middle_obj import * #from features import import string from string import split from string import join import re from monkey import * """ Milkshape 3d ascii format notes: Basic outline of format: --- Start of file --- Frames: Frame: Meshes: Materials: Bones: --- End of file --- A material index of -1 means no material. """ def export_milk( points, indices, normals, out_file ): """ """ fw = out_file.write fw("// MilkShape 3D ASCII\n\n") fw("Frames: 30\n") fw("Frame: 1\n\n") fw("Meshes: 1\n") fw('"Bla" 0 -1\n') # num verts fw("%s\n" % len(points) ) for p in points: fw("0 %s %s %s 1.0 1.0 0\n" % (p[0], p[1], p[2]) ) # num normals fw("%s\n" % len(normals) ) for n in normals: fw("%s %s %s\n" % (n[0], n[1], n[2]) ) # num faces fw("%s\n" % len(indices) ) for i in indices: fw("0 %s %s %s 0 0 0\n" % (i[0], i[1], i[2]) ) fw("\nMaterials: 0\n\nBones: 0\n") f = open("bla2", "w") export_milk( points, indices, normals, f ) f.close() exploratio-0.1.1/lib/urdpyg/converters/ms3d_ascii_importer.py0000644000175000017500000003544311143032667023142 0ustar renerene""" Copyright (C) 2002 by Rene Dudfield. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. """ from middle_obj import * #from features import import string from string import split from string import join import re import os import md5 import cPickle # TODO: # *- read meshes. # - read materials. # - read bones. # - figure out how to send data back into the middle_object. # probably register with a callback function, with initialize. # - Add checking in to see what features are required. # """ Milkshape 3d ascii format notes: Basic outline of format: --- Start of file --- Frames: Frame: Meshes: Materials: Bones: --- End of file --- A material index of -1 means no material. rotations seem to be in radians """ def str_parse(string_to_parse, conversion_list, seperator = " "): """ returns a list of formated converted variables based on the string_to_parse - um.. conversion_list - list of functions, to convert parts of the string. Use str for strings, int for ints, floats for floats etc :) seperator - string to use to seperate the elements of the string. Will raise exceptions if string not correctly set up. Or if data fails to convert. """ #TODO: Allow the conversion list to contain sequences of functions. # This way you can return subsequences. eg. # line = "0 1.0 1.0 1.0 2.0 2.0 2.0" # (flags,pos,rot)=str_parse(line, [int, (float, float, float), # (float, float, float)] # flags - 0 # pos - (1.0, 1.0, 1.0) # rot - (2.0, 2.0, 2.0) # # hrmm maybe I could just use regular expressions... split_list = split(string_to_parse, seperator) if(len(conversion_list) != len(split_list)): raise "wrong number of converters, or string doesn't match." return_list = [] for x in range(len(conversion_list)): return_list.append( conversion_list[x](split_list[x]) ) return return_list def chomp(s): if s[-2:] == "\r\n": return s[:-2] elif s[-1:] == "\n": return s[:-1] else: return s class milk_mesh: def __init__(self): # (flags, triangle indicies(a,b,c), # normal indicies(a,b,c), smoothing group) self.triangles = [] # (x,y,z) self.normals = [] # (flags, x,y,z,u,v, bone index). self.verts = [] self.mat_index = -1 self.flags = -1 def __str__(self): return "triangles:%s:\nnormals:%s:\nverts:%s:" % (self.triangles, self.normals, self.verts) class milk_material: def __init__(self): self.material_name = "" self.ambient = [] self.diffuse = [] self.specular = [] self.emissive = [] self.shininess = -1 self.transparency = -1 self.diffuse_texture_name = "" self.alpha_texture_name = "" class milk_bones: def __init__(self): self.name = "" self.parent_name = "" self.flags = 0 # three floats. self.position = [0., 0., 0.] # three floats. self.rotation = [0., 0., 0.] # list of tupples(4 floats) self.position_keys = [] # list of tupples(4 floats) self.rotation_keys = [] def __str__(self): a = """name:%s:|parent_name:%s:|flags:%s:|position:%s:|rotation:%s:|position_keys:%s:|rotation_keys:%s:""" % (self.name, self.parent_name, self.flags, self.position, self.rotation, self.position_keys, self.rotation_keys) return "\n".join(a.split("|")) class MS3dImporter(Importer): """ """ def __init__(self, wanted_features = None): """ If wanted_features equals None then all features are given.""" #FIXME: add the supported features. supported_features = "" #FIXME: call superclasses init. #Importer.__init__(supported_features, wanted_features) def Initialize(self, file): # File to load milkshape data from. self.file = file self.total_frames = 0 self.meshes = [] self.materials = [] self.bones = [] def Start(self): """ """ b_error = 0 f = self.file raw_line = f.readline() line = chomp( raw_line ) print "line :%s:" % line print "raw_line :%s:" % raw_line while (raw_line != "" and not(b_error)): if(line[2:] == "//"): pass # read in the meshes. elif(line[:7] == "Meshes:"): self.ReadMeshes(f, num_meshes = string.atoi(line[7:])) # read in the materials. elif(line[:10] == "Materials:"): self.ReadMaterials(f, num_materials = string.atoi(line[10:])) # read in the bones. elif(line[:6] == "Bones:"): self.ReadBones(f, num_bones = string.atoi(line[6:])) raw_line = f.readline() line = chomp( raw_line ) print "line :%s:" % line print "raw_line :%s:" % raw_line def ReadMeshes(self, a_file, num_meshes): """ """ f = a_file self.meshes = [] for mesh_count in range(num_meshes): m = milk_mesh() line = chomp( f.readline() ) # Get the name, flags, and material index. # split by space, join the last two, and the first. split_parts = split(line, " ") (m.flags, m.mat_index) = str_parse(join(split_parts[-2:]), [int,int]) # join the first parts of the string then take off the " at the # start and at the end. There should be no new line. m.mesh_name = join(split_parts[:-2])[1:-1] # Read in the number of vertices. num_verts = string.atoi( chomp(f.readline()) ) # read the verts into a list. f_readline = f.readline v_a = m.verts.append for vert_count in range(num_verts): v_a( str_parse(chomp(f_readline()), [int, float, float, float, float, float, int]) ) # Read in the normals. num_normals = string.atoi( chomp(f.readline()) ) n_a = m.normals.append for norm_count in range(num_normals): n1, n2, n3 = split( chomp(f_readline()) ) n_a( [float(n1), float(n2), float(n3)] ) # Read in the triangles. num_triangles = string.atoi( chomp(f.readline()) ) t_a = m.triangles.append for norm_count in range(num_triangles): flags, i1,i2,i3, ni1,ni2,ni3, index = split( (f_readline()) ) #t_a( [int(flags), float(i1), float(i2), float(i3), # float(ni1), float(ni2), float(ni3), int(index)] ) t_a( [int(flags), int(i1), int(i2), int(i3), int(ni1), int(ni2), int(ni3), int(index)] ) self.meshes.append(m) def ReadMaterials(self, a_file, num_materials): """ a_file should be set to after the Materials line.""" # Structure of the materials section is as follows. # each part takes up one line. # material name. in "" # ambient, 4 floats. # diffuse, 4 floats. # specular, 4 floats. # emissive, 4 floats. # shininess, 1 float. # transparency, 1 float. # diffuse texture name. in "" # alpha texture name. in "" f = a_file self.materials = [] for x in range(num_materials): # read the name of the material. try: #line = f.readline() m = milk_material() m.mat_name = string.strip(chomp(f.readline()))[1:-1] #print mat_name # ambient, 4 floats. m.amb = str_parse(chomp(f.readline()), [float, float, float, float]) # diffuse, 4 floats. m.diffuse = str_parse(chomp(f.readline()), [float, float, float, float]) # specular, 4 floats. m.specular = str_parse(chomp(f.readline()), [float, float, float, float]) # emissive, 4 floats. m.emissive = str_parse(chomp(f.readline()), [float, float, float, float]) # shininess, 1 float. m.shininess = float(chomp(f.readline())) # transparency, 1 float. m.transparency = float(chomp(f.readline())) # diffuse texture name. in "" m.diffuse_texture_name = chomp(f.readline())[1:-1] # alpha texture name. in "" m.alpha_texture_name = chomp(f.readline())[1:-1] self.materials.append(m) except: # find the line number of error. error_pos = f.tell() f.seek(0) l = f.readline() cur_pos = f.tell() line_num = 1 while cur_pos < error_pos: cur_pos = f.tell() line_num += 1 l = f.readline() #print line_num raise "Error on line:%s:" % line_num def ReadBones(self, a_file, num_bones): """ a_file should be set to after the Bones line.""" # Structure of the Bones section is as follows. # bone name in "" # bone parent in "" # flags(1 int), position(3 floats), rotation(3 floats) # Position key count (int). # position key block(position key lines long). # # Rotation key count (int). # rotation key block(rotation key lines long). # # # NOTE: The comment in the ms3d acii importer code states that bone # parent is alpha_texture... this is obviously a bone parent. f = a_file for x in range(num_bones): # read the name of the bone. line = chomp(f.readline()) b = milk_bones() b.name = string.strip(line)[1:-1] #print ":%s:" % b.name #print "b.name-1:%s:" % b.name[-1] #print "b.name-2:%s:" % b.name[-2] #print ":%s:len%s" % (line, len(line)) #print ":%s:len%s" % (line[1:-2], len(line)) # read in the bones parent name. line = chomp(f.readline()) b.parent_name = string.strip(line)[1:-1] #print ":%s:" % b.parent_name #print ":%s:" % line # Read in the flags, the position, and rotation. p = b.position r = b.rotation stuff = str_parse(chomp(f.readline()), [int, float, float, float, float, float, float]) (b.flags,p[0],p[1],p[2],r[0],r[1],r[2]) = stuff # Read in the number of position keys. num_position_keys = str_parse(chomp(f.readline()), [int])[0] # Read in the position keys. for x in range(num_position_keys): b.position_keys.append( str_parse(chomp(f.readline()), [float]*4) ) # Read in the number of rotation keys. num_rotation_keys = str_parse(chomp(f.readline()), [int])[0] print num_rotation_keys # Read in the rotation keys. for x in range(num_rotation_keys): b.rotation_keys.append( str_parse(chomp(f.readline()), [float]*4) ) self.bones.append(b) import operator import time operator_add = operator.add def convert_array_shape2(verts): return reduce(operator_add, [x[1:-1] for x in verts]) def convert_array_shape3(verts): """ Converts a [[1,1,1,1], [1,1,1,1]] into [1,1,1,1,1,1]""" out_verts = []; map(out_verts.extend, map(lambda x: x[1:4], verts)) return out_verts convert_array_shape = convert_array_shape3 def convert_milkshape(a_file): """ Returns a list of [points, indices, texcoords] Only converts one mesh. """ # DO_PICKLE = 1 from types import FileType if type(a_file) == type(""): a_file = open(a_file, "r") # see if a_file.name +".old_md5" exists. # if it does compare the md5 of the current file, with that of the old one. #TODO: what if it is a StringIO file? need to see if .name attrib exists. if os.path.exists(a_file.name + ".old_md5") and DO_PICKLE: #print "getting old digest" old_md5 = open(a_file.name + ".old_md5").read() # NOTE: may want to use mmap here. #print "getting new digest" new_md5 = md5.md5( a_file.read() ).digest() #print "done: getting new digest" if old_md5 == new_md5: # return the pickle if it exists. if os.path.exists( a_file.name + ".pickle" ): #print "loading pickle" print a_file.name try: pickle_file = open(a_file.name + ".pickle", "rb") return cPickle.load(pickle_file) except: pass a_file.seek(0) imp = MS3dImporter() imp.Initialize(a_file) imp.Start() mesh_data = [] for mesh in imp.meshes: verts = mesh.verts triangles = mesh.triangles normals = mesh.normals points = [] indices = [] texcoords = [] bone_indices = [] normal_list = [] # convert the verts to a list of points( one dimention ). map(points.extend, map(lambda x: x[1:4], verts)) map(normal_list.extend, map(lambda x: x[1:4], normals)) # get a list of texcoords, one dimention. map(texcoords.extend, map(lambda x: [x[4],1.0-x[5]], verts)) #texcoords = map(lambda x: 1.0 -x, texcoords) # Get the indices. map(indices.extend, map(lambda x: x[1:4], triangles)) # get the bone indices. bone_indices = map(lambda x: x[-1], verts) """ print verts[-1] print points[-3], points[-2], points[-1] print points """ #print len(points), len(texcoords), len(indices) assert(len(points) /3 == len(texcoords) /2) #assert(len(points) /3 == len(indices)) mesh_data.append( {"points": points, "normals": normal_list, "indices": indices, "texcoords":texcoords, "material_index":mesh.mat_index, "bone_indices":bone_indices} ) #for md in mesh_data: # if md[3] != -1: # md[3] = imp.materials[md[3]] milk_scene = {} milk_scene["materials"] = imp.materials # make a couple of dicts from the bones. # A parent dict, keyed by bone name, valued by parent name. # A #for b in imp.bones: milk_scene["bones"] = imp.bones milk_scene["mesh_data"] = mesh_data if DO_PICKLE: # make the pickle, and md5 file. if not locals().has_key("new_md5"): a_file.seek(0) new_md5 = md5.md5( a_file.read() ).digest() open(a_file.name + ".old_md5", "w").write(new_md5) an_f = open(a_file.name + ".pickle", "w") cPickle.dump(milk_scene, an_f, 1) return milk_scene def test_MS3dImporter(file_name): #points,indices,texcoords = convert_milkshape(file_name) meshes = convert_milkshape(file_name) if(__name__ == "__main__"): import sys if(len(sys.argv) != 2): print "" sys.exit(0) test_MS3dImporter(sys.argv[1]) exploratio-0.1.1/lib/urdpyg/converters/test_cal3d_exporter.py0000644000175000017500000000142411143032667023150 0ustar renerene""" unit tests for the cal3d exporter. """ import unittest import cal3d_exporter class Cal3dExporter(unittest.TestCase): pass def test_Cal3dBone__to_xml(self): """ does converting a Cal3dBone to xml work? """ b = cal3d_exporter.Cal3dBone() print b.to_xml() def test_Cal3dSkeleton__to_xml(self): """ does converting a Cal3dSkeleton to xml work? """ s = cal3d_exporter.Cal3dSkeleton() s.bones.append(cal3d_exporter.Cal3dBone()) s.bones.append(cal3d_exporter.Cal3dBone()) s.bones.append(cal3d_exporter.Cal3dBone()) s.bones.append(cal3d_exporter.Cal3dBone()) print s.to_xml() if __name__ == "__main__": unittest.main() exploratio-0.1.1/lib/urdpyg/converters/md2_importer.py0000644000175000017500000002556011143032667021605 0ustar renerene""" Copyright (C) 2002, 2003 by Rene Dudfield. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. """ """ For reading md2 files. A description of the MD2 file format can be found here: http://www.ugrad.cs.jhu.edu/~dansch/md2/ """ import array import struct import Numeric N = Numeric # some maximums for the md2 format. MD2_MAX_TRIANGLES = 4096 MD2_MAX_VERTICES = 2048 MD2_MAX_TEXCOORDS = 2048 MD2_MAX_FRAMES = 512 MD2_MAX_SKINS = 32 MD2_MAX_FRAMESIZE = (MD2_MAX_VERTICES * 4 + 128) tMd2Header = { "magic":0, # Used to identify the file. "version":0, # Version number of the file (Must be 8). "skinWidth":0, # Skin width in pixels. "skinHeight":0, # Skin height in pixels. "frameSize":0, # Size in bytes the frames are. "numSkins":0, # Number of skins associated with the model. "numVertices":0, # Number of vertices (constant for each frame). "numTexCoords":0, # Number of texture coordinates. "numTriangles":0, # Number of faces (polygons). "numGlCommands":0, # Number of gl commands. "numFrames":0, # Number of animation frames. "offsetSkins":0, # Offset in the file for the skin data. "offsetTexCoords":0, # Offset in the file for the texture data. "offsetTriangles":0, # Offset in the file for the face data. "offsetFrames":0, # Offset in the file for the frames data. "offsetGlCommands":0, # Offset in the file for the gl commands data. "offsetEnd":0} # End of the file offset. def from_c_string(c_string): """ Returns a python string from a c string. Ie it looks for a null character in the string and returns everything before that. """ to_return = [] for x in c_string: if ord(x) == 0: return "".join(to_return) else: to_return.append(x) return "".join(to_return) class Md2Model: def __init__(self, md2_file_name = None, md2_texture_file_name = None): """ """ if md2_file_name == None and md2_texture_file_name == None: # Don't open anything! pass else: # open the file name given. self.f = open(md2_file_name) self.md2_file_name = md2_file_name self.md2_texture_file_name = md2_texture_file_name self.image_name = md2_texture_file_name #tMd2Header m_Header; // The header data #tMd2Skin *m_pSkins; // The skin data #tMd2TexCoord *m_pTexCoords; // The texture coordinates #tMd2Face *m_pTriangles; // Face index information #tMd2Frame *m_pFrames; // The frames of animation (vertices) # List of skin strings. self.skins = [] # The texture coordinates. string of shorts, u,v self.tex_coords = "" # Face index information. # [[vertexIndices,textureIndices], ...] # [[[0,0,0], [0,0,0]], ...] self.triangles = [] #vertex_indices = [] #texture_indices = [] # The frames of animation (vertices) # [[frame_name, vertices, normals], ...] self.frames = [] self.header = {} # copy the header as 0. self.header.update(tMd2Header) def Load(self, md2_file_name = None, md2_texture_file_name = None): if md2_file_name == None and md2_texture_file_name == None: # Use the internal names. if self.md2_file_name == None: raise "Object has no file to load." pass else: # Set self.md2_file_name = md2_file_name self.md2_texture_file_name = md2_texture_file_name self.f = open(self.md2_file_name) self._ReadHeader() if self.header["version"] != 8: raise "file corrupt, version is not 8" self._ReadMd2Data() def _ReadMd2Data(self, md2_file_name = None, md2_texture_file_name = None): """ """ if md2_file_name == None and md2_texture_file_name == None: # Use the opened file. f = self.f else: # open the file name given. f = open(md2_file_name) header = self.header # Next, we start reading in the data by seeking to our skin names offset. f.seek(header['offsetSkins']) # Depending on the skin count, we read in each skin for this model. s = f.read(64 * header['numSkins']) self.skins = [s[x:x+64] for x in range(0,len(s),64)] # Seek to the texture coordinates. f.seek(header['offsetTexCoords']) # Read in all the texture coordinates in one fell swoop self.texcoords = f.read(2* 2 * header['numTexCoords']) tcoords = struct.unpack('%sh' % (header['numTexCoords'] *2), self.texcoords) self.texcoords= Numeric.array(tcoords, 's') del tcoords # Move the file pointer to the triangles/face data offset f.seek(header['offsetTriangles']) # Read in the face data for each triangle (vertex and texCoord indices) self.triangles = f.read(12 * header['numTriangles']) tris = struct.unpack('%sh' % (header['numTriangles'] * 2 * 3), self.triangles) # vertex_indices 3 shorts, texture_indices 3 shorts. triangle_data = Numeric.array(tris, 's') del tris triangle_data = Numeric.reshape(triangle_data, (len(triangle_data) /3, 3)).astype('s') # make two seperate arrays. One for vertex_indices, other for texture_indices. # every second set of three. self.vertex_indices = triangle_data[::2] self.texture_indices= triangle_data[1::2] # Move the file pointer to the vertices (frames) f.seek(header['offsetFrames']) # Read in the first frame of animation self.frames = f.read(header['frameSize']) # I think the first part of this is: # 12 bytes, 0 - 11, float scale[3] # 12 bytes, 12 - 23, float translate[3] # 16 bytes, 24 - 39, char name[16] scale = Numeric.array(struct.unpack('fff', self.frames[0:12]), 'f') translate = Numeric.array(struct.unpack('fff', self.frames[12:24]), 'f') print scale print translate frame_name = from_c_string(self.frames[24:39]) # Make an array of the bytes. byte vertex[3]; byte lightNormalIndex; # vertex_light_data = Numeric.array(self.frames[40:], 'b') print vertex_light_data[0], "vertex_light_data" print vertex_light_data[1], "vertex_light_data" print vertex_light_data[2], "vertex_light_data" print vertex_light_data[3], "vertex_light_data" vertex_light_data = Numeric.reshape(vertex_light_data, (len(vertex_light_data)/4, 4)).astype('b') # Need to seperate the lightNormalIndex from the rest of the shite. # that is get rid of every 4th element. # We won't use the lightNormalIndex, as that requires a 1.7MB quake2 specific normals file. # Make a new array with 3 elements instead of 4. vertex_data = Numeric.zeros((len(vertex_light_data),3), 'f') # loop over vertex_data, and put the first 3 elems in there. #TODO: there has to be a faster way to do this... # Maybe the code I'm copying from is wrong. count = 0 print vertex_light_data[0], "vertex_light_data" for vert_light in vertex_light_data: # we swap the second, and third elem to match opengls coord system. vertex_data[count] = Numeric.array([vert_light[0] * scale[0] + translate[0], vert_light[2] * scale[2] + + translate[2], -1 * (vert_light[1] * scale[1] + translate[1])], 'f') count += 1 # Multiply the array by the scale, then add the translate to the array. # This will transform it into an array of floats. #vertex_floats = vertex_data * scale #vertex_floats = vertex_data + translate #print vertex_floats[0] print vertex_data[0] print len(vertex_data) print vertex_data[156] print vertex_data[476] # We have at the end. #TODO: read in the rest of the frames. # Numeric array of floats, there will be one array for each frame. self.vertex_data = vertex_data # Numeric array of shorts. self.vertex_indices # Numeric array of shorts. self.texture_indices frame_name # a numeric array of shorts, in range 0 - 255. self.texcoords = self._ConvertTexcoords(self.texcoords,self.texture_indices, header['skinHeight'], header['skinWidth'] ) # TODO: what is it? maybe need to convert cstrings to python strings. self.skins def _ConvertTexcoords(self, texcoords, texture_indices, w, h): """ Flips the v coordinate part, and makes a new array based on the texture indices. texcoords - texture_indices - """ texcoords = Numeric.reshape(texcoords, (len(texcoords) /2, 2)).astype('f') # flip the v coordinate. count = 0 for u,v in texcoords: texcoords[count] = [u/w, 1 - v/h] #texcoords[count] = [u/w, (v/h)] #print texcoords[count] count += 1 # allocate a new array with the length of the indices * 2. print len(texture_indices) new_texcoords= Numeric.zeros((len(texture_indices) * 3,2), 'f') max_xyz = 0 count = 0 for x,y,z in texture_indices: new_texcoords[count] = texcoords[x] new_texcoords[count+1] = texcoords[y] new_texcoords[count+2] = texcoords[z] print new_texcoords[count] print new_texcoords[count+1] print new_texcoords[count+2] count += 3 return new_texcoords def _ReadHeader(self, md2_file_name = None, md2_texture_file_name = None): """ """ if md2_file_name == None and md2_texture_file_name == None: # Use the opened file, if good. if hasattr(self, 'f'): f = self.f else: f = open(self.md2_file_name) else: # open the file name given. f = open(md2_file_name) f.seek(0) header_data = array.array('i', f.read(17 * 4) ) h = self.header h["magic"] = header_data[0] h["version"] = header_data[1] h["skinWidth"] = header_data[2] h["skinHeight"] = header_data[3] h["frameSize"] = header_data[4] h["numSkins"] = header_data[5] h["numVertices"] = header_data[6] h["numTexCoords"] = header_data[7] h["numTriangles"] = header_data[8] h["numGlCommands"] = header_data[9] h["numFrames"] = header_data[10] h["offsetSkins"] = header_data[11] h["offsetTexCoords"] = header_data[12] h["offsetTriangles"] = header_data[13] h["offsetFrames"] = header_data[14] h["offsetGlCommands"] = header_data[15] h["offsetEnd"] = header_data[16] return h exploratio-0.1.1/lib/urdpyg/converters/middle_obj.py0000644000175000017500000002457211143032667021274 0ustar renerene""" Copyright (C) 2002 by Rene Dudfield. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. """ """ A scene graph which will contain all sorts of information about 3d scenes. Advantages this method will give you. - Allow importers and exporters to be written independantly. Just write an importer and you can take advantage of all the exporters. - Able to choose a disk based, or memory based conversion. - Don't have to support all of a 3d format, can support only parts of a format. This is necessary as development nearly always happens incrementally with 3d format converters. This means importers and exporters will have to specify which elements that they support. - Extensibility: the system is designed to be extensible. So that if new 3d formats are added they will not affect the old ones. This is done by having all importers and exporters contain a list of features which they support. Here is an example of how it would all work: First the importer and exporter(s) will tell the middle object which features that they support(or are interested in). The importer will read in what of the 3d format it understands, then pass the 3d data onto the middle object. Also passing on the features which the importer has imported. - Support multiple exporters being used at once. But only one importer being used at once. Multiple exporters will be useful to save having to do the import step multiple times when exporting to lots of formats. - Each exporter will be responsible for setting which features that it wants to export. That way it is possible to - A feature can be any sort of 3D data. We want to support as much different data as possible. Here is a list of 3d data that I can think of: = mesh data, = vertex, face lists. = vertex shading information. = per vertex, pre face UV information. = Scene graph information( this will be hard ). - It could be a graph of indicies to other objects. Maybe a tuple of (feature_name, index into list) - Not sure how inheritance will be handled. = bezier lines, and patches. = nurb lines and patches. = Texture mapping info. = cameras = lights (point, spot, omni, ambient). = image maps for terrain. = Material information. - color maps. - animations. - bump maps. - alpha maps. - smoothing. - specularity. - May provide a heap of helper functions, to help make converting the data easier. Providing different views of the intermediate data. eg. converting a mesh made up of 4, and 3 sided polygons into a mesh made up of only 3 side polygons. Here is a list of helpers: = ngons to triangles. = curve patches to triangles. = per face, to per vertex uv mapping conversions. = scaling. = rotation. = converting which coordinates are up, sideways and depth. - May need to implement a disk based dictionary, and a disk based list. As the shelf object which uses a database as a backend is pretty lame. It can only store objects of a certain size. Also they are only dicts, not lists. - Perhaps to save on memory, we could write certain features to disk(using pickle) whilst the other data is being converted. - Importers, and exporters don't necessarily need to read or write to files. eg. They may comunicate directly with a 3d editor, or a game engine. They could use a COM, CORBA, or xml rpc interface. - Should try and make use of other converter libraries, eg lib3ds. - importers and exporters should be able to do things like eg. only export frame 34 of the animation. Probably have to expand on the feature passing idea for this. Diagram of how feature information moves around: user --wanted exporters--> middle_obj user --wanted features for exporters--> middle_obj user --wanted features--> middle_obj importer --supported features--> middle_obj middle_obj --features to export--> exporters - Reduce the number of unnessesary calculations. One way to do this is to have the importers and exporters know which way certain things are defined. Eg. the coordinate systems: in one format x may be depth, and in another format x may be depth but comming into the screen. ei. if two formats both use z+ as depth then there is no need to transform the coordinates when putting them into the middle object. NOTE: supplying all different types of stores in the middle object should not be mandatory. There will be a default for the middle object which all importers should support. NOTE: This information would be stored with each feature. Eg, Meshes.Triangles.PointOrder.Supported.Value = ["clockwise", "anticlockwize"] Meshes.Triangles.PointOrder.Default.Value = "clockwise" - If Conversions have to be done on data, make sure that the conversions also change other data which is dependant on it. The only example of this that I can think of at the moment is Indexes to things. eg. face list index to a heap of points. Maybe we should keep some dependancy information somewhere. Think about this some more. Maybe too much effort. - Keep documentation of all the features. Documentation of every feature will be kept in a master feature list. The master feature list will be generated from the importers,exporters, and the middle object. The middle object will be updated sporadically when new features come around. The documentation of the features will also be taken from - Keep a central repository of all the different features. Supply a report of which importers/exporters support what. These need to be automated. The feature objects of a importer/exporter/middle_object are python objects which contain __doc__ strings. - With (importers/exporters) and the middle object, the feature objects are used differently. The middle object uses features to store not only the documentation on the various features, but also data itself. - Make some test importers, and exporters. A test importer will fill up the middle object with what ever data the exporter asks of it. A test exporter will ask the middle object for some data to export. If we can get an test exporter, and importer which supports _ALL_ the features, then testing will be easier, and there will be some base implementations for people to look at. - A validate format function for each format may be useful. One function could be used to validate the import and export plugins. It is optional to implement this. Quality plugins implement this ;). - A DoValidation() method for importers and exporters may be useful. This way an importer/exporter has the option of validating the data or not. Not validating the data may be a speed increase. Both in speeding up the conversion and speeding up the writing of the plugin. Validating data during the conversion may also be faster than doing the validation as a seperate pass. It is optional to implement this. Quality plugins implement this ;). """ class MiddleObject: def __init__(self): """ """ # A dictionary of features self.features = {} def AddImporter(self, importer): """ importer - an object used to import 3d data into the middle object. """ def AddExporter(self, exporter): """ exporter - an object used to export 3d data from the middle object. """ def SendFeatureRequestsToImporter(self): """ Goes through the exporters and gathers a set of features which need to be sent to the importer. """ class Importer: """ Used for importing 3d data into a MiddleObject. This is a base class, to be used for importers for various 3d formats. """ def __init__(self, supported_features, wanted_features = {}): """ supported_features - features which the wanted_features - defaults to all features if not specified. """ self.supported_features = supported_features self.wanted_features = wanted_features def GetSupportedFeatures(self): """ Returns the features that this importer supports.""" return self.supported_features def SetFeaturesWanted(self, features): """ Used to tell the importer what features the importer should pass onto the middle object. NOTE: this does not mean that the importer should not load all of the 3d format. If it has to load it all so be it. Just pass the features that are wanted. """ self.wanted_features = features def Start(self): """ Starts the importer doing its import thing.""" raise "This importer is missing an implementation of Start()" class Exporter: """ Used for exporting 3d data from the MiddleObject. This is a base class, to be used for exporters for various 3d formats. """ def __init__(self, supported_features, wanted_features = {}): """ supported_features - """ self.supported_features = supported_features self.wanted_features = wanted_features def GetSupportedFeatures(self): """ Returns the features that this exporter supports.""" return self.supported_features def SetFeaturesWanted(self, features): """ Used to tell the exporter what features the exporter should get from the middle object. """ self.wanted_features = features exploratio-0.1.1/lib/urdpyg/converters/test_middle_obj.py0000644000175000017500000000023511143032667022321 0ustar renerene""" unit tests for the md2 importer. """ import unittest class fsdf(unittest.TestCase): pass if __name__ == "__main__": unittest.main() exploratio-0.1.1/lib/urdpyg/music.py0000644000175000017500000001255211143032667016125 0ustar renerene# file: music.py # purpose: responsible for loading and playing music. """ """ music_events = ["game over happy", "game over sad", "game start", "using special", "close to end of game", ] # Different conditions for happy/sad music. # # 2 player, single computer. # - game over happy. # 2 player, networked, local loses. # - game over sad. # 2 player, networked, local wins. # - game over happy. # 1 player, human wins. # - game over happy # 1 player, human loses. # - game over sad. # import os, glob import pygame.mixer import pygame.mixer_music from rdpyg.util import cyclic_list import config import sound_config from rdpyg.util import vtimer class Music: """ Useage: m = Music() m.Play("intro") m.Play("bla") Need a directory ../data/music/intro.ogg """ def __init__(self): """ """ # for playing a track in 0.3 sec. self.play_timer= vtimer.vtimer(0.2, self.music_play_callback) self.fade_in_timer = vtimer.vtimer(0.2) self.fade_out_timer = vtimer.vtimer(0.2) # don't let it do a callback until finished. self.play_timer.set_finished_no_callback() self.fade_in_timer.set_finished_no_callback() self.fade_out_timer.set_finished_no_callback() self.fade_in = 0 self.fade_out = 0 self.GetFileNames() vol = config.max_music_volume self.SetMaxVol(vol) pygame.mixer.music.set_volume(vol) self.SetLoudVol(vol + 0.2) def SetLoudVol(self, vol): """ louder than max volume. this is for special occasions. """ if vol >= 1.0: self.max_loud_volume = 1.0 else: self.max_loud_volume = vol def SetMaxVol(self, vol): """ sets the maximum volume for the music. """ if vol >= 1.0: self.max_volume = 1.0 else: self.max_volume = vol def Load(self, music_type): """ music_type - one of the music types from the sound_config. """ if music_type == "intro": snd = sound_config._get_random(sound_config.music_types[music_type]) else: snd = sound_config._get_cyclic(sound_config.music_types[music_type]) pygame.mixer.music.load(self.sound_dict[snd]) def music_play_callback(self): self.Load(self.music_type) pygame.mixer.music.play(self.loop) def GetFileNames(self, path = os.path.join("..", "data", "music")): """ returns a dict of file names to be used as music. keyed by the file name without path, and .ogg. path - to the file names. """ #self.sound_list = map(lambda x:x[7:-4], glob.glob(os.path.join(path,"*.ogg")) ) self.sound_list = glob.glob(os.path.join(path,"*.ogg")) #print self.sound_list, "sound list" self.sound_dict = {} for sound in self.sound_list: file_name = os.path.split(sound)[-1] file_start = os.path.splitext(file_name)[0] self.sound_dict[file_start] = sound return self.sound_dict def Play(self, music_type, loop = -1): """ Starts playing the music. """ self.music_type = music_type self.loop = loop if pygame.mixer.music.get_busy(): # fade out the playing track, then play ours. #pygame.mixer.music.fadeout(1000) self.fade_out_timer.reset() self.fade_out = 1 # get ready to play the next song :) self.play_timer.reset() else: self.Load(music_type) pygame.mixer.music.play(self.loop) def Update(self, elapsed_time): """ To be called frequently. """ self.play_timer.Update(elapsed_time) self.fade_out_timer.Update(elapsed_time) self.fade_in_timer.Update(elapsed_time) if self.fade_out: vol = self.fade_out_timer.left_normalised() vol *= self.max_volume pygame.mixer.music.set_volume(vol) if self.fade_out_timer: # we have faded out. self.fade_out = 0 self.fade_in_timer.reset() self.fade_in = 1 if self.fade_in: vol = (1. - self.fade_in_timer.left_normalised()) vol *= self.max_volume pygame.mixer.music.set_volume(vol) if self.fade_in_timer: # we have faded in. self.fade_in = 0 if 0: if not (self.play_timer_100.just_finished or self.play_timer_1000.just_finished): if self.play_timer_1000 or self.play_timer_100: # check to see if there is any music playing if not, play it. if not pygame.mixer.music.get_busy(): self.Load(self.music_type) pygame.mixer.music.play(2) #if not pygame.mixer.music.get_busy(): # pygame.mixer.music.load(self.current) # self.Play() def Pause(self): """ pauses the music. """ pygame.mixer.music.pause() def UnPause(self): pygame.mixer.music.unpause() def Stop(self): """ """ #pygame.mixer.music.stop() pygame.mixer.music.fadeout(100) exploratio-0.1.1/PKG-INFO0000644000175000017500000000034211311214451013430 0ustar renereneMetadata-Version: 1.0 Name: exploratio Version: 0.1.1 Summary: Exploratio is a 48h ludumdare game Home-page: UNKNOWN Author: Rene Dudfield Author-email: renesd@gmail.com License: UNKNOWN Description: UNKNOWN Platform: UNKNOWN exploratio-0.1.1/data/0000755000175000017500000000000011311214451013245 5ustar renereneexploratio-0.1.1/data/gfx/0000755000175000017500000000000011311214451014031 5ustar renereneexploratio-0.1.1/data/gfx/cavern1.png0000644000175000017500000011613111310746606016114 0ustar renerenePNG  IHDR5sRGBbKGD pHYs  tIME 8tEXtCommentCreated with GIMPW IDATxw|TUwJ&̤^R$P@ZЋDXl*u-?Zֆ~,JY4i ]jBz?2){~>B&g=@AAtX2AA @   AAA   HAA$  HAA$  AA @   AAA   HAA$  HAA$  HAA$  AA @   AAA  % :h4d2o߾HHH/^Ǐ(++CUUXA @+))q㐝v?/++æMGaϞ=$ I +={ߏI&A}'HA$)?(..Bpw.\y?'A$ BjW^aΝ:~8ƎG! C Zo~ 2iX`j5 = DW=4mŋؿ?f3 -$|wu;2.A!JHtyy%''cՈ A$ BlL&u]v*СC1yd20AA ( * <#$#AJ]b v@@.]ŋM^FӡW^HLL˲hnnJBSSjjjp)8q+A hYf?ƻK&/VQPPK"++ ~~~P*9?f3؈#G7ݻQVV 2 ![8zѫl ͖-[8VK ^z%>kXcǎqk׮Ɏ>>?~'M~9-uW_E߾}P(#+((h?ɰ @ jZ HIIAEi,\ҭC Lŧv"$ B.L&zsF#RSSEi!Cvrrr0j(J{Cx`ޥKp12,A Bbb"/bEg,_3̛7OioiRxMOc\z K$0dy峽& ZFIB[[ahll$2]nݺyu:FJKz(F`ɒ%df4a2Vp)۷JyzBS*aXxi_5 H`q\?ņNCFF>?44& Mz.66K,c=V`ܸqj=PQQg?ěoG , oӧ?Q q3 :HJJ?J%ЀSN㨬mUzkFFG#''&Ih4bΜ9{nw40Ezz:~ ""޷z dTknݺշL @P@#<<ƕ+WȊaǡׯ_GSS,K7eYhZDEEaʔ)1bnInlXP]]#G?ￏǏl6{G^b: l2*Hiii(**¶mdoh"]z=n6$$$`ӦMm%൶0BJ%Dz,Dz,0L?A5D^|Ekᖗs6lT*׾kII '.SٳܠA8d羾Bpov60[oE /Nǝl'J鐝-F<Ø9sWV1oԩSվSSS"+99.K yyyKۿ @OAȓNLIIINZȑ#EcpQ6K0 ^x<`"1EVŜ9s5i4.OdL;UD* J>>> DNNJJJ0j(dff`0,˂eY2ƣ#FrZQL&f͚%!77a2<^eYaXr "P \ӡW^.}SL#?~#FHİطo_^+8+ovlݺ$Jjj*\co:DRB8*Ft-O۝0`[m6lٲ۷obivD0I:LDDD6m³>R3N<!CU|}}U1???}~LL ֬Y{ĉ+PT.~\\>8s ***e?~eee$>XHN4 JR +,zOCCw1nҥZkaDs-^/^N׿7ouVovhllV^iZϤ>p1h' JKK͛7sG&Fp JLLJKK: .11=׿z<6S-v2&&+5kxd+^ok׮yM&(*T*,]YYY| yJJ EJhM,*{zFAII f͚>}YZ2dOKbԩx0eKF t?)؂aBRno @^1cFR9,b̙=lv9I5,mcs=ߪ5k󑛛g}JRJ`vZl޼;vHq!''_'`n]R \]bŊ=(07d EL& 2 n ̞=:[no }E0A___^sV'X̶x"KVc̘1=bbb .~tt4/_^a0x`t{ݻԄHddd )) AAAjdffW^0`>۷UUUػw}}};te2<#Vj*X,lܸr3:7#<%^#Gr r"^r+++Oa2ws 2 ͜9S\XXoNIIi?Py= s{m?;w`}ll@cc#WYY}\TT/ܢ1dƥkUܷ~Q;WTTp3^ЛW^V6V ÇomV_-ֶ@x8a2xknϋyd"d^B^/* z/?a޼yv=oB@II &N ֜F=1p@~իW A=Zj*/D) :t́f0lJblj&6NVzʲw;{PP&Mq p<%%%())AZZ~ߣ̫[K {n׮]éSp`XhLӦMÇ~[ya0ӟ7|+2c wÞ={}vTTT ׯ_lj'p)teYh4!%%ݺuCmmmӧqQTVVX"'hMD||͟'''CPt(|Xj؎ I -_|***~-mŷj5Ə#F/ gCWw;w.f\rka/mJ^Zw4F# A{OEEN::$%%h4zջT* w}?O(--LOOޮoUVy<׀s!00& &L=(--Ů]pIVׯRRRZbZV'b֭T(;vl;W}Gt:t۶mu`0 --M4@@@~:€ZFqq1x ы?PVV=aÆaӦMlFsKm[qC|~/j4a4QQQ!5dggc٢IHHqqq VիWqY\x55`0 ""IIIA^Nsrsw;v ?4uj~ 8tV^waaadS((BLQƗ:A*rRb رޢ<22Ry%22ӦMÁpe1V9#55[nBCC3ՁPL`͚5X`AUUUػw/?+W 88DDDKADD͛ɓ'R066@T'hqu`h47oA!..=R/ lj^)))fwt%ӱqF<7 ]ɓ'#..m6\pΝt:,^Ji= 111{xGOήcС1cƎNz$%%!))Iů?_T;$-J%f̘ȷ[nĨP(騁vOySN j7iiiN]heРAoRu9(??ݢGmKmmovӉ-a!Eаa0uT/u0 /_˗ʐdGBFN82@GGG#00Ptv d5j-v<,0-- wu&ض0bժU޽(Vl\ ` iiix /tZݚ7OL&~",,LtF $,[ .颋rf2G[TXjj p 41cSϖX0 3f m+J]ݻcرָ#9RQQk׮Pϔl޼Fr޹bH'X"ڵkE %i8I^ZƤI( BkwhZWb?zh'Q F,+ضeĊVZ,ۜy֭v=|ġ; sSS*++ykz'ʐS@2 dVСC%`ȷWL)tL&ymW^J1ڟa :ђH9,'Hp ‹/{rvC@[6qIUWWۍStu9m4QzT*1k,QU!C-ƍR1bT mdYK,*|­%'zcAϞ=% 0HOOkUZپ}]+D?yG]ϟǙ3gx???L2EÇ.IIIe!!!6mӿǧ aS?o`0nw,//]80@ۜ~~~(..MBJNJ+.`+|rځg*0 aÆan[@a0|p&◴ BppdeY :8|2 LQۉ/F)[8qɓ'n)FWdk~{+V@aaKc#Gx;zGފTո;E;.KZjt]2q]Z-)Z-Dk'kJ%JJJD9>1c$bcceQՊ+<# ^ڦ`xcʕ.fJw}dV ^د_?%ŖZNHAT*L>.W dȗ>&&}kjj3,Xpl*--er"(( ͛sN?3^޽믻7odtt4L"mt IDAT}Fq0˻}$$++K)/X1|]|ABBc6J=tPQ^v/ /ѣe5N4vj5FJ[z h="ʼn}CGL@ SSS^9+JL6M/_ܙZF1w\{ T111&wSeY >n(0={6[$&&5\p}Ō3$u|||<T*{$/###ߪ3Z-6lV'$''-(Ƨ,}0LXx,+\m,NQ&ѼEpp]?ݝ>& ˖-#/>>]TƍudP(&{7n%|e!Vpiߛ9mҤI֭/ﺔZࡇAZy)e){\NMMs={kkw_XX$V&W^uI^Gxx[m$&&J毣t +V0zdddA 77W[|WB_k.ح1jkk(9xĸ8Hq1ucH5n̛AK/ b$ɓ']ʠ߷o_ Ę1cjcȐ!䋰0,_T0* 999 D}ڎhjjɓ'ecW>ܛԣGDD]]]i4,X@諪pqx}||P\\,8I@%ߞNFFF駟˕+Wܻ,+F= Hfoܸqsw[nxꩧD#I_Zرcؿc0R^^RlY)l&e%xիWvY񒟟}v3 RWWRL+hZb\J(F< #""+Wƃ~>k4,YDrvLNN6pRR=lphhWb$]8B@nnU*0RVXі ضmG>+** ÇMHHرc; Qո{+g6wܵ8p$Nz 6L?qF:80 #ή΂$gl6:&LXKk׮9}(1'!!A6ޤSN ~ZZ Wo:ͅg2/g6Q:W-^X2Y @ku{U8\9`/ͭ冨eAAAuuuN $/s>>> $n̙3+&oyjxyw:0 ~aٝiSL&I>@6ȑ#mxg˲HHH?Qwvu BTO> eY?^rϩ;@O3SLiW%<<\eG>a&C^bq6obcc1n8=뵵Z$S@Q:wΝ;'XFEEEepIQ=^PZtqYZׯ : DEGN '*xs">-½ދ,7SdYV2mԉ޸8\x.q)$O׬w}'`0C܌~d+c)--ٳgRF1mǦMV"SR ޕHdYV)))t8Vz h=ۛ28qB?eQOiMM ok.A=,J2X5,X am8r BRm:""" #FO>>>Ζy.DѣGvPWWFY|X6zss`O-MP@+ ɭT+9fG8h3Nj=P(n)v܉ FÇ]f;=z< jjjd =RSS1p@ۈpu%j0$7; }矝$7''jkZGҶ:pf郘mll`ޞ? qIA<,bĈp>F;#ۢr9 v.m~c2${eKeddrʕ+عsg?{BBVo #d1r1PG;dYV6\٪8pljq!t7e1zhDEEuŶ+BY]vܾ~: C?3͂'OBUoa>A V>&ko`dF6KΜ9#2[?;_~Ektd___?#==]{}C̙3? [JsJ @ /D!O@{bWPH:D[RSSRRRn:IW»b8cd!IHHt$$$Dx̪*|vsUcNmm]ii (((͸APY)>B|v+999?\ 㫯t|*,,N+ٿxrNO/۪qq]/{Hr$r\dFSfBә3&&&a1` DIۙ~%d-`Z;[;W, Laj&Z3fȪ\!|_i#!w|+Fwq F`Bn93~3t=ubb"Iۊ|}ׯ," >11QxwB"PJzx8qnVnvm'Ν`0NØ1cn- +**`9Rv =`0f V"τ.OH-yg1cbcc)h/_vQ$=GIccce ,: @6G p lٲE0ڻwo-6]x-w.HlVu(L<"SԒw̘1Cc @PQQǏ;; >zA(>>^v:fn @gGQ*3f,Cj֓B.V(`v$d(w{1eY.lHJ:aI2 dѲHi*B\~/`)`  ei;㾢+RUU @8+bmA֙HJݻw;W*9s$lB 99Yv7''nM=.gl۶ 8Y`0,**Bpp q[Dw}?8RdW W_}ŋ 7P6lךRWad$11ѭMF)SȾ: @ Byyy2dRSSoT;pZ|ᇨs}dEΝ;VNæMRVB{iQ^UUz 'NJKKs+a^dWoszZZ?c(**BQQ֯_8FBq^x|vOZlGӧcǎ=g!44cכt  W4fXK???[NɟB1z^lr䥥#9y$^}U۷o_Y3.. ¦Ml_v- bx7o̲l@ˉO?&LI${z=pi~eYw}]:y%#q&& {&cDGV^\\\ ^ǜ9s잰5eL!%%íkjjyfI/a0eʔ.3NvZAqq$KΝ×_~ e1h ۔adggcܹ0 [|Ict#RZ*8+郄HJJǬY$} yꩧ<6t:vm]®oɓ'w8]B~^cƌA@@ӿh$) l9R'IJgϞ-hy W_}25(**y¶>>>HKK/lΞVT:t5+(6m"##V,Vرc Ԅ~JHpBdDGGyCCf͚%*j-rJ'%%y$_8+Cd6Vɓ 'N@TTrssA~ ;worP*mIcv1L>|8=~]wĉfvDz,틍7BBP80 RSSIpH\ rA^h46Ha岬FӧO'|oܸQTv_ >ܦWT=z4qxa ;ƍRmAȂ˗/ڞ-ω/~.su!00ݿ5ʫ?lQPPٳgw4 ?>{9YmL&ǡjZt<A2`׮]QQQ=ztĉT*b `0] V\͛7ҥKP(Gaa!fΜ|YrFGGM|mG] @ gꗤ$-|}}oG 99/"pݻc8s Ґ$k!߭[7`XXX|~IAHJ8pPZZjsҔC8>INNƣ> Ri7YaY֩r -- ja&9g/A8UUUna"tYaDEEo`08 oi;%HAHC< Ν}JdpBL&ݻSN!HAx }GfEEEdpBj;P Aqwב 255suAx^a.jX @ #TYeɓ'cٳg+FHzOP_~$ aF,[ f9y!^ek$8 ?N\^N3u=lX @ YDZFnݐ & 77dXBAPح[7zA8sK/887ne_z@T>>>]67# @ H?+ B} =m-l/:VLaDcl {F}c=V#Ӫև>U췽X,;bWZ/ µh}!05OGvyki~<¶F;Ia!='|j '&0٢ {Yaa~rnմyٖ<Ӧ-20Dv 0j.9ʛ-:ۂV_擕ص\/>ax#kgvG=p0/Ŏ/a67/~nۙOT9\3* ,BT/|dYOVݸmqP* lWmqNELBMjYZ실|,{kHUعD/{r6Nڊq>~ J~[cҽx lb X-wz>O#3c'^ǷOXf-1hhl6;ʡwx@;u1r*WĴ0KKζuˍâ,l| /s( Wkmœe(JL[>yS a^ldL *p/˰P⏟om@V[$dvOUaRK"617@C}}:8/˽+ !(ԄʫX7,d`@| L_J:۳x0 U/yŲ{#QI8]KGBDss#JNEOg}ޅ(E@7#04N b=yy߫:r}+ X=:/}ɹmgɋm3G[moѱ}ŷ5s-RsǴ6?cW\xO.?@N/Yzo. V5hAv&ju~l۶ !!!Lh 7>i{! +_v_`nlh#nO˄Y^^BqMj7+{6k0ڹj"[?~ [>: xB:XݕRz07֢ _=s^m~F/z#/"gLT_X=^ h4~Q[U+;]tdbpcq{dpxO.t`j hj;`nn3ǠTRXC`8V}h(3EaPBr/]ݞӥ{qQ.9yZ]t ݎYxޡ%>EmbB1X h 3sw/ET~ܩܹeHTc F\AK7vV-DYp ,9 0 6,a`iƯ?zB L!Ѯh h4|u8_vW/!6C[} b>6QݎL&s? 'A3l#n܂=g##M `̵PVBoݢ{ѳ_끠/g&9>-"{ )јG^;"ȳfw|oPWq-5s-^rۋ/Ok'Z?:<^vbASSˍ 8u2Iۜ Ƹֶ'^K!&[ol7@_ 7xhQ܄DTU\5`0sA}Ӷ6oaSBx)H}'!9.hnnw̓n,L˱aXTsmI|xpatN 6FiYN\l[()$!Td FЀ =pϸz җh5a8DgCb\u'BFlM^r^>EaJXsX844qZR1Ȏ[[[-ǴvZWR` #Js&%O-kO b\PH}'0yɥ%BPMMj?8hǎU5Lۗ7 !JVٚɴw#X`:II7& 8mc34ذ=q.bi @Ljui #G:o*a%>^bASZҎ-ϰmm/ޙGYLvHʪrMH"nmm_mֵuZFUYM$ELBdL29?&<3<3zK$Ù9s>{{˱t/:s%bf@ *Fɝ}Y(O? 8M@sWr* -- cǎu>|pP=-ICZ L-' -ۦ-ܧpcGʾZM[ hDZm2` / .$I]G2*NKv z)o;S˨mR9_G#+#ô-e@{3]FEEEHNNBQ&XfQ5|A1=sՙ,V@iZ L-' ڦ-m }G0m(׶u.@EEw0,w"Ͼ첄vZF-5L p6}>ҧ`edQrFɕΣcƌq@dǃAA>=;: Wۚ L ZM[m }D`edQrFɕofMtaҤI=~Ǖ"=+ Rpv hlMZNZGDi k>BQ032L[0Jx;\Yðatv꾂m<3@kWr 77!0Zj6mcj/#eaF%Wֵ 8$R'.dYbb̙\r۶ZNZM[25M-%Wֶ{aRvI#%pS˨QڂfG0䌒ծc^ؽ,:@Sp3ȑ#=nj%0Zj6m7m_G#+#Ì3Jssg^=۸-]Fg!]ǎ[ǁGJ:{ITW`j9Ih-m }D`ed`\qٽН~4 u 5pR{*s[QK-ڦ-m }D`edQrFɕ?@ש]4 ;dX]m6pTg'OB`j9Ih6m6}>mFi Fɕ,Gץٓ%gCDLftb //CUW`j:"J[05]fQr߶٣{yMgsLz4@E a `4g;ƍJ`jԢm"nfG VFi Fɕeo9$PBeǗqh98R /|jr-G#}( }D`edQrFɕݗ=t" :;Ug]s=(]&^2e ŴZMZN@pb20䌒+o/{zHssN8dh5:?X1pI$''@\S˨Vm=؊uHm32(9oe;bXm@su2j([<+Ʃjr-ΏsߋeG0䌒+o[=tBtٻDs p(,,D||<:A,>BQ6#Ì3Jv?Љ.uQ Hc6;p|u᪾`by^i#Ģ/#+:W8tP@&t N}s$W"0U$mss/#aF%[bz|[m>\ՉFϲg:SIBi ɃXLL }>tgd`϶uإH]_f[/HHH@_tgw L& -' ‹-"|cGnaF%WvНpˉet\u]=z8;8ծSIBKJ[xG ~A6#Ì3JB@!#ô^RT*gap3fE\(0$hm>2FHM 3J(ղu0 |y}]{*@'L-kE[s,ζWw&_DZUi!}Ĉ/#g+#Ì3JC*C'w#YR|÷N =v,p(\+S]`j)<=WF|xY'LcD$ķnݐh6I%GbalGzجmal}[cxO}_!C CW+uPIq bQb ɹ؁} b۰:;6A윶b޼aSG{zqX;!u}g55FH'%X mۂh >CG-w>_6`[8H:#FMPէ3hFaWx,8M={;{ѥp'{#>HRGc|{ =Vh7K7osDgv4M_gEϮ[~N`pX>m!д&IXy IDAT;&lKܰ)Mܷ{-:n!%牨yjEɕ= }3}Y—~Y%%$nj찣Em=EA %܈ӮFKct$Q",y$r7_݊*Te2qH߽vm袢1tT%SfdX`n[ۢ( Bԩfoa]+>:]J2 bJt߶o Ń7k$IK痝_cM!fCP[|=E۫UܪCp_EUi.<~~"q5V⫨G#N4V :&NEǩ=/!;T~sy$^7٩oon.J!ˊ Jlga5"::mݔx|d6r@V&Mz4ZJVk"ڝcjkkqbynLKJNŒw׷,00 P5%aX$Qrld[$>IB?{_Xj{E &J4]rm=&8]TW[dNT}dm¸̾}ߡC081vߏLKɟ `9r$:M:dc[jm\u&εb'l{V۾CGC.<-#G t@ݥStm 6 c`77{sZx4+~<{`p sh8U,9w !!$uGX/<$U|j}/QoMmO)wjwTyqhwK2 J?{7Vq3(<9 1jԮoJۃbe#**\7 KR_ I[U<|9b!d%f1*Xc ښ\!G+ZtI$-ԧlyFEtQeQQQ}~,|o"(%0MFgZ{g_pM 43ҠGtL\H2|m`(A_kԢ,jQzb/X)%Gן vnAѰY%Wj حvؔzvy Wtj{7[Dpxng=7JHG,nL Os u׼ǫ0;0{-\.8gmᲃlf]nooj%*{>wx4MV7pw;=#!!I7 M.}?+pGY).]}.&.87}v!Hs~g46%z'"::m]m8 %v}ga0w'ϊf$''w/\vvԭШDcu 1t<~j:u{(;׼+q*0$ vہbh/Ô?@mE.~v!$68i8/.t@g-֤$Iu4U&?h]]躾o}c{ډC{Sp͍9-j;\mT]I?koO~Y_ DK8Zko?/Ȣ#.IǗ"rD$'f6bŗolUX;t} :&}ѩ=F#e8=m-P/h e>(9mVx@N҃?NX{}_^5uF+Mm3n*0WG1tMB3L PB@{ !B2\V"N) !B"db!BHAH!BH!B( !B !B$B!B!B!PB! @B!BH!B( !B !B$B!B!B!B!PB! @B!BH!B( !B !B$B!Mp 33ĬYpWc֬Y4 !BZ;vO v;~GB!j ?I$G;'tR@B<`Za4a2HJJBll,C*LBJff&?K/X#Ұedfff͚馛( !^$!ȑ#Z^'_~&L=CENNydggwݱcǐ˗ꫯ!)`RZZZlذ"_~%||4!/v]=Jc҃}[V۷"P%**;!qqq4!=hlljBHYoРA4! }̙34!7Jr FC҃!CxhzB(Ih;NYfJB.:::i$B _zXt-p8N#B(Ix4/2ZZZh4B<i$yBWX:@rrrm6n&q>}:[֭w]-$q8^}VBB=#8p@ٳ֭իq5H}4ŋqcʔ)4h F#F!Ͽ4=z}II FRNgРA^}EEE4!Pmrssa2{!RSSQYYI#߼y3 G"+ў7q, >LCB( .f4m6Iw),,Dii) G"+k~7|zNNN^{5r-[k!''!0sL[0۷oWf3;F㑈fڴi;vƊ`w}_ƞ={gx( ` \wu^kq|͆LD4III3f466ƊP֯_V`޽4 D?|@#y-`!?C6$رc.:::c+1 OalUj?W]u.XRtttx}ϊ+o>&ɯ+*++Q]]M&>>zjj*ME H!F#[|9X999ظq#?CX@ 8vXNֆ^{ 4O28t&M_ɓnUMFFl6__Mz=.\g;wҥK)eee^VZGi0B֭[%Mgggq8Ƞ"R 䤤$IE233QQQ֭ /\wuxMkkT{{;6nnk Daa!H"%@I$I*㵮mUUjjj;*8Պ|ڵ 7oFaa!fs>˗cժU˲x 2-- zW`;xXlɲbx+^nG~~~XiFV+RRRpGVVV/xgQPP_---%߹s''7ukojj" oE%I&Ʉ!!D]T`E( }_j}'< r(*$ hEBBQFmmm^ #`Zs>ӑa7U+>&2>#^:l+*|\x_$ɔ)S666 \Z[[<>>FR^z|pLuMY?3ؼys>|_ʐv\[=Knc֭qD$ӧOGttߩ& 'O"ՊraP>3?~\V(((XP`ssQ3Ʉ<,)SG);;[*BO>tD]v.>gXEEFgΜNmm-6nw[RP wॗ^ J{lF#6nHB$Պ͛780iҤ>p8r$PTTuM$FUUUUѡ(Z8 '>]Ŕ/^Vۧ ?Aƶn`o!}ͨDee%)\9υ,8u !b`{-n*))L8l0#f., ֮]1l*P]]2*../-- /~_◿%^xQAM sMq_8=p̙VǦM"bHcݫj(55'Øݻw#//ϭOS 'N8Fϫ>m]󩭭EJJς]~/'M.(6v;-[e?Ə4]+ꉓ'O*3IOzzղngJD(#oY'SXX:I0|p+>Ǐﲲ2;+,G%ch΁!B/Xpm۶ mmm>pt2чõjsQTMMMXreDN|yyyluxK0O ꊊ XV|W};v,~`~b4~4b}YEyy9BjI&Εe7nDvvv9PqqɳJVe$)#G3ł|qėEguu56z\r FM֭[#!ZZZ(bGcccȌp-:,]4/֪뢴4"u`W,Pq%vK)*7+Aρ/]F'bP#*@FFnLe| #ʉ5& |O!Ǐܾ~QmZw^mR\\hN7n\@%"^gy&RtT=P8f-$N8F޽;IeM{ S7^Jnn.,8t$(يRk| !9_DyyyH JIIdbBIޯ]-^}e|.,,iܬ?IXVlٲ6-vZ[[#WjRSS;dU}'ZzKm.F9‡v39sF(m\\Ǿ׿5b[9M&h4JǏ"??_ y[VPcQODh4խ$9n, F}'33SLy~'-EEE3555\L\xaÆ8`n*v:ty>p8jEUU 80Pi0DƄ ]S|:pćl6|2je2T/W)v̟?dWTT(Zh2=g= WܬzZJyyyXԩ@Y'TT)P I8zsXݮ}G6Dddde$ގ?zF%Umd2!???`RRRN mڴ رc5id2aɒ%.UjoCCCG xȹl?Y0SZZ(1FL6ͧ#'N0˗/ǂ 4JZݻwcǎʡTw(O]OQ_n444}֒$y B`׮]Φo ̗NII)B|>UUa8j…K- +2jb…Xrf}l6ɓơjjjBmZj*^;*++FX,]KK /_g@rg9n OF#>Sj]_ X,S,asASNXM+f3~mܹSSZE\e^^.]:`5Z)ǎUqS[[<~R-OYgox X98 Ԯ #F`ذaAECkTiSGq8qTm0Xgtܻ*hllıch>t1e4Z[1l͚5>/Լjr7 !b+>066'N /5kjDCC.\L&bܵkW Gk֬ H`l6* @}v~FMM 9?}4kv8,BRpر!PkԌ"xYZZ C 6lA ~=ZWСCp$aȑ)LhOOԾfMmg$HII4s08y򤦇f|o&*++9کD{{;[U;sLX 3j- .\&=̫.<IBq",̙3_faѢEMj 2o 4KO@|q(ooJ ;;[ى[Ҩ^4'999@os ~]aP~oXV[1(!9“^jN$weCqsC{{fMeZԐӧOGtttX׭[;ve]Ç{A{9INN&PVVFd2:vU1 HMM x`0O>իisU5\222= ې .,A\tvvg$ <8߹YYYPV(**臀$=KӢLNff&~y̛79-  U;!2+4kbϞ='p.**š5kʇhkk \% ;cҥ, ㇸ/--DvQ|uزe .]^{ {/|Aر_"lٲE4l5Yގ;wF$ ƍ p8ař3g}eY_ݯF#N:v[n`?%%%}ĉ4tݬւHel6"55<^}UR^ 6:677Emm-rrr2WfH3G6ǡgѫ_FFPPPGy/ /kUUwFt2224Nc=o{0: xwӟկgo'5/ƙطo 5iyۈa%8t}JKKCB믿O 喦,ؿ?zꩰ?֦*9u>#RH0s&:nV}ZUMdىjlٲ?<#-:'@EE gjE0$I #SZ(v܉^g׶]GG*** ~;> -5hllDnn.nƈxQ^^߳7nOS\{t^?ɇ~ݓrlذ>`o677ԩSAPn 0غu+~mTTTl6rQXX=|c„ 3g&OS.6ca/  444`̙eC]]]Ъ5eԄm۶!55sK/s>YR$$m ?b'###"d‡~~}]) .طsl6,^sŌ3"hnnI5,hd2ɓĉ'lA2LC~~>AK.jɓ'.wvG]>T{Amm-V^}{`׮]~a3O :>rޤuȑ{ZVl޼Nɩu88x ;|! 6m.h%777tČ3ȑ#Ellt|EK$qEoXlRRRĘ1c\u؇BfÍ`[!^  $-踮./  x/R*;&2466r]`/ʕW^;v`Ĉnd?hkk EGG$O?~{DV^ԠAf͚cOgpZM4 uuu& B]?LZz۶mQTTNȲs>l5yyy[1w\\{0(..Fcc#Μ9(?w1gL4)"d’%K& 99MMMfÞ={"F;nXpȑ qSA[ &.._!f|Ǹ[`@AA֯_> O<.\Ǣ"aʕW$!** F­ފGyߝDZhhhÇz\q1cƌ>o:y$v|iý~s7K }g"(KT-t7H믿^K+++b [JOGyկE^d–-[rJ9r;鐘9s`ԩHHH!C0k,\qr>ߎ#F@a5jfϞ/F;u,sp\.M&SȢ,!feR$I: gÇ'nvQRRVbbh"qw9s|;"..Dttqqq"))Ip bҥ˒R=]t:+**bccETTTXzEGGDqWO>Dư.}s%e`(R]t:+dA/Һnnc"6o,fϞ-bbbT suu]'֭['.֭[֭[C+O?&u9m4b $dY+rw5i$yoHHHJHH ,&)2--ML:ψܹsʕ+Evvz^|'\s Err7nҥK"y4/jol: _|/\8p@Uu_#2xW'Ȳ? @B!%KVV+(  !. //OFÄPBH*J6mؾhhh@]] MQ^!W(((@QQ0a„ڵk-`BH!EEEؿ? 3f ***vz=~in ! +`ڵ ZA8LP#BfX,>}:w[˖-KB"pxgWV'N#BHbժUX`L&V#33PB!>G-\$BИfnرc0LERRd̛7wmB!B$۵$!66:јH'eOX=?^7? z6ҩx'KW2(=*`C;qnEK&81H7EdSo2|sM5] ˯_E8V`6jH?H@"@fɐ_C${ٍVz`x:G?}Lvx'fsט!a>K|2=VTyȾ 9a@ G0Qr8`6fZwu J%sg @+H旆Yz,5_,7wa6K @q>^nU;f0~-]}rig^%·8 9Fim.p15y g (Bl9 »&6{ r~]Pz8A胸˲heg]w^fp'FC}xUTBÿ`#2qd^ź2r.m eB%v1"x'A: *Zm<wa4< f/nDz9\&i6<A+;J0|Zedv%L;xPPyu@? @}@l6x5}aIx}ȱ[->Bm Zj?ҩ@fւsX50,4Sij׎xg!%.*Q Po3BO#e$ 24 c -/ſs uzx٘\A0 LV} "r,ĵdC@ AEn=@p0,>F?w/̄;FX M}D!$;T^օPNwCPƐ20.ׇ^ ]6| 4q)Z`vrIF DQŕZWjqeJS1Ul` 8l SDKu)%~ll,mdSDb{\^×:+1UK+`>yOq@)0d]݃4?ρg{XJ8v@.b:-o L3o~G Nߟ| 8=v],[YW# Jg "l_ල;1^+|v+{%<{O"=1{ٸsGKOl_?y ڟbwl,UPJG?~|q yUk1OWPnHnbd狩#I)Xʝ5f?P` b 3^,3ϭ?|h"M`!@ W"j.[6Qà@:#nf_ 쭜9ےX[Kl\v(ڼ #Vy$|@r@St瀖VSh<u=wW-Z]] 2U{?]@û|x,|z `~?O#&`g\$wa6y ze!x'`d̳ ݩLd)~N؈=UdWټd*Gxp_Z |p͟id#fr@:}A[2^CQ2 hn_s'yF)ڞ>7S, ߠs2 ҃H۫ ڇr2;z eA - e| ~#o`k޽2X>AJmt|xR6XF}X0p%B͂*DHGv@J7\fa ,1Dy7ᡖ'Xʟbiū\҉M, p^5 ̋!44a 達BE{ԑ@T|eD,}&ibeo&HRji#uT>CM<";*RGDZ+|6#oŸSD[jT*U~@a% 1VhR H=8urGR4ab xe bo|'-v8~C[i*-!zyNJ&}ჄDh:R17JЉ NO ΋0A{+䘉1MWDn=¼{ߨ~#[;R@7a9puobhVI""D^ 4),[i69;뺽,bŚWT}= s2eDȿSkr.2 HdKRո:`HwsGI*݇O+8N@=D/-EQ+^)J[ߑ]SaكYTOU*R/ I:ae*lIRҞYUQCV(^wM}Ia!8_60zj _~N8eƱ|2l3K&AW 03sv2ѳKcD^Uqk|b7Wh6d۰ѯWN?á eJ 7<g.AUٽXz-MR"*Oxo`TϤ@H9'@sxA%3{8T `},>"7OVukaUtS ahP^=CoE -/8Q:ʡ/qWy@BqHyRuq"!~xNГWNb/]FzNRC#jQ&cUK.b vAO&/D+;l[4't%%[Oˆ F!D0@? Prr& ~UśАknӈӡ  4hv=4Ž @߬1K?ƂB Sy~ 1ar>K \#&=20Wo<XW4H!}t/_k]֋ Dx 2S^v,_[m).@M4.rm|MHhD"$82(ad74SJ"auCn%_K[ЗxDFT.}BDmL@C򁀠^V`tkض#y@ŷЇ {#1Gmj \+շ/6 z ya~;1F8~FV,H{¸<ᡕAKΒBg,vXFǘ >aTllFh#F?'qA(T=V^(uFpW1 =O3_Iw|Ϫ_ʡU/oVN'5c2`\m\DiRY&7sfU` zca+αsx](F6E:Kl/( _1 Ā( 0(¼,451̘h&oүDĎ bUvl;Tt["jՍ6RzK/^SpbJ a!eEAz,(EpS@7Eo;9Pa]~^uN#"fh9 w.Ip8!F/hMLNc a=U +jۓrL_us +9ތ ՍVOxS0;oY&ϒxY=Yѐ #f;R  mOGmx'ͮT>o1'kp}1ixA^E0аn]짽w;leAL - [X 6: \#6u?treUͬs\T06b^oV4P2& aq:~`amt}k<*ʘtɾ( 5Ww.,^!Dd] JӾ7T26,| kOP*<O:ͬE@@W%SӜK pK7dyz-̶_7ᶍi~ֱYHuAVK)QFie CiKDXbWfL=wޯa9qqpG}0$=h6G3,qYvscb%X3Oe:@'SD /d^}9< _1:ZyzPOaF( ~"S-Zo96OMh&:拺<#$i>I$FR (?M(|3 S `)/_^Jty"p…[l'7'qtxm>dw'E"4U6q#/5m7(--hE+ +>^R@ֱ -hְ\ض-"V4|\{CCOOO2>H^*+QQ2{5#d\Ldnz,a ncupGG^lo`KM}}}/ʶ|8%h> oط{%ђX4UcĢ1rO֟c+p7F GyOč 9DlRxύFc|KʾΛI&G //.9 '룼k v%“',S2pDk74&5pq֬㖨j^7RjX {zt'HlwKW!˧g¡tbXt.ξj{zE˃-Ĕ(\=yk_~V]9yAN3$ ͵avqqQ݈.eM ~OFmcO(/}ez:e|o)eaIK~"pKc`?kDkBam/HG_GFZM7&ςHi^4,?͞ΔҲ(|U@iθGKAir|&Aa =^5 ЭeŠ&eYJJPF ЗػKXnMGi+ENyP䲧UM1 {P2z630n:vtup63MtZrDfW`np PAE}pQT6;=M\Q1(A>e%yj>em aaUH+H 9G#1D\DGeX[*SJMjnR>s3[:O:CذU% `me~1w.+r~Hq_䠤'R\ T̓y2,>+E}MZx,jhj@J@QnQA}/CUF^TrcgT$)zʘO%uErܪ` VVQ叶( 8B-?0VRwyiIENDB`exploratio-0.1.1/BUGS.txt0000644000175000017500000000023311310662142013636 0ustar renerene Crash BUGS: ******************** ******************** Game play bugs. ******************** Graphic bugs. ******************** Sound bugs. exploratio-0.1.1/README.txt0000644000175000017500000000027611310662046014045 0ustar renereneExploratio http:// run_game.py KEYBOARD: arrows or wasd - to move. F10 pause. f/space/ctrl to fire. MOUSE: button one fire. button two move. JOYSTICK: game pad move. button 1 fire. exploratio-0.1.1/TODO.txt0000644000175000017500000000000111310662052013634 0ustar renerene exploratio-0.1.1/LICENSE.txt0000644000175000017500000004316011075056646014204 0ustar renerene GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License.