home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 56 / CDPowerplay56Disc2.iso / demos / blade / data1.cab / Program_Executable_Files / Lib / GameStateAux.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2000-10-27  |  15.3 KB  |  414 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 1.5)
  3.  
  4. import os
  5. import cPickle
  6. import BBLib
  7. import Bladex
  8. import Reference
  9. import Breakings
  10. import PickInit
  11. import types
  12. import ObjStore
  13. import cStringIO
  14. PickDataBase = { }
  15. LoadedPickledData = { }
  16. aux_dir = '.'
  17. FixDataBase = []
  18.  
  19. def LoadGlobalCompVars(filename, dest_dict):
  20.     file = open(filename)
  21.     u = cPickle.Unpickler(file)
  22.     u.persistent_load = persistent_load
  23.     ret = u.load()
  24.     file.close()
  25.     for i in ret.keys():
  26.         dest_dict[i] = ret[i]
  27.     
  28.  
  29.  
  30. def InitGameState(aux_dir):
  31.     global PickDataBase, PickDataBase
  32.     PickDataBase = { }
  33.     filename = '%s/PickDataBase.dat' % (aux_dir,)
  34.     funcfile = open(filename, 'rt')
  35.     p = cPickle.Unpickler(funcfile)
  36.     PickDataBase = p.load()
  37.     funcfile.close()
  38.     print 'PickDataBase read'
  39.  
  40.  
  41. def CleanLoadTemp():
  42.     global PickDataBase, LoadedPickledData, LoadedPickledData
  43.     PickDataBase = { }
  44.     LoadedPickledData = { }
  45.     LoadedPickledData = { }
  46.  
  47.  
  48. def EndGameState(aux_dir):
  49.     filename = '%s/PickDataBase.dat' % (aux_dir,)
  50.     funcfile = open(filename, 'wt')
  51.     p = cPickle.Pickler(funcfile)
  52.     p.dump(PickDataBase)
  53.     funcfile.close()
  54.     print 'PickDataBase written'
  55.  
  56.  
  57. def persistent_id(obj):
  58.     ret = None
  59.     
  60.     try:
  61.         ret = obj.persistent_id()
  62.     except AttributeError:
  63.         pass
  64.     except Exception:
  65.         exc = None
  66.         print 'GameStateAux.persistent_id()', exc
  67.  
  68.     return ret
  69.  
  70.  
  71. def persistent_load(obj_id):
  72.     if ObjStore.ObjectsStore.has_key(obj_id):
  73.         return ObjStore.ObjectsStore[obj_id]
  74.         filename = '%s/%s.dat' % ('f', obj_id)
  75.         dat = GetPickledData(filename)
  76.         
  77.         try:
  78.             LoadedPickledData[dat.persistent_id()] = dat
  79.         except KeyError:
  80.             LoadedPickledData[obj_id] = dat
  81.  
  82.         return dat
  83.     
  84.  
  85.  
  86. def SavePickData(filename, data):
  87.     if PickDataBase.has_key(filename):
  88.         return None
  89.     
  90.     string_file = cStringIO.StringIO()
  91.     p = cPickle.Pickler(string_file)
  92.     p.persistent_id = persistent_id
  93.     p.dump(data)
  94.     PickDataBase[filename] = string_file.getvalue()
  95.  
  96.  
  97. def GetPickledData(filename):
  98.     string_file = cStringIO.StringIO(PickDataBase[filename])
  99.     u = cPickle.Unpickler(string_file)
  100.     u.persistent_load = persistent_load
  101.     ret = u.load()
  102.     return ret
  103.  
  104.  
  105. def GetPickledObjects(filename):
  106.     '''Loads the ObjStore file'''
  107.     global FixDataBase
  108.     f = open(filename, 'rt')
  109.     u = cPickle.Unpickler(f)
  110.     ret = u.load()
  111.     f.close()
  112.     for i in FixDataBase:
  113.         func_id = i[0]
  114.         ob_id = func_id[0]
  115.         if ObjStore.ObjectsStore.has_key(ob_id):
  116.             cl = ObjStore.ObjectsStore[ob_id]
  117.             cl_to_assign = ObjStore.ObjectsStore[i[1]]
  118.             exec 'cl_to_assign.' + i[2] + '=cl.' + func_id[1]
  119.         else:
  120.             print "Can't fix FixDataBase.", ob_id, 'Nor found.'
  121.     
  122.     FixDataBase = []
  123.  
  124.  
  125. def LoadAutoBODs(dir):
  126.     files = os.listdir(dir)
  127.     for i in files:
  128.         pass
  129.     
  130.  
  131.  
  132. def LoadMMPs(files):
  133.     for i in files:
  134.         BBLib.ReadMMP(i)
  135.     
  136.  
  137.  
  138. def LoadAlphaBMPs(files):
  139.     for i in files:
  140.         Bladex.ReadAlphaBitMap(i[0], i[1])
  141.     
  142.  
  143.  
  144. def LoadBMPs(files):
  145.     for i in files:
  146.         Bladex.ReadBitMap(i[0], i[1])
  147.     
  148.  
  149.  
  150. def LoadBODs(files):
  151.     for i in files:
  152.         BBLib.ReadBOD(i)
  153.     
  154.  
  155.  
  156. def AddWeaponToInventory(inv, weapon_name):
  157.     object_flag = Reference.GiveObjectFlag(weapon_name)
  158.     if object_flag == Reference.OBJ_BOW:
  159.         inv.AddBow(weapon_name)
  160.     else:
  161.         flag = Reference.GiveWeaponFlag(weapon_name)
  162.         inv.AddWeapon(weapon_name, flag)
  163.  
  164.  
  165. def LinkRight(weapon_name, inv, owner):
  166.     weapon = Bladex.GetEntity(weapon_name)
  167.     owner.Unlink(weapon)
  168.     inv.LinkRightHand(weapon_name)
  169.  
  170.  
  171. def LinkLeft(weapon_name, inv, owner):
  172.     weapon = Bladex.GetEntity(weapon_name)
  173.     owner.Unlink(weapon)
  174.     inv.LinkLeftHand(weapon_name)
  175.  
  176.  
  177. def LinkBack(weapon_name, inv, owner):
  178.     weapon = Bladex.GetEntity(weapon_name)
  179.     owner.Unlink(weapon)
  180.     inv.LinkBack(weapon_name)
  181.  
  182.  
  183. def LinkLeft2B(weapon_name, inv, owner):
  184.     weapon = Bladex.GetEntity(weapon_name)
  185.     owner.Unlink(weapon)
  186.     inv.LinkLeftHand2(weapon_name)
  187.  
  188.  
  189. def AddQuiverToInventory(inv, quiver_name):
  190.     obj = Bladex.GetEntity(quiver_name)
  191.     inv.AddQuiver(quiver_name)
  192.  
  193.  
  194. def SaveFunctionAux(func):
  195.     
  196.     try:
  197.         func_type = type(func)
  198.         if func_type == types.MethodType:
  199.             ob_id = func.im_self.persistent_id()
  200.             return ('m', (ob_id, func.im_func.func_name))
  201.         elif func_type == types.FunctionType:
  202.             return ('f', (func.func_name, GetFunctionFile(func)))
  203.         elif func_type == types.BuiltinFunctionType:
  204.             return ('cf', (func.__name__, 'Builtin has no known lib'))
  205.         
  206.         return ('n', (None, None))
  207.     except Exception:
  208.         exc = None
  209.         print 'Exception in SaveFunctionAux()', exc, ' with function', func
  210.         return ('n', (None, None))
  211.  
  212.  
  213.  
  214. def LoadFunctionAux(func_id_ex, res_obj = None, res_field = None):
  215.     assign_func = None
  216.     if type(func_id_ex) != types.TupleType:
  217.         print 'LoadFunctionAux() ERROR, invalid parameters', type(func_id_ex)
  218.         return None
  219.     
  220.     func_id = func_id_ex[1]
  221.     func_kind = func_id_ex[0]
  222.     if func_kind == 'm':
  223.         ob_id = func_id[0]
  224.         if ObjStore.ObjectsStore.has_key(ob_id):
  225.             cl = ObjStore.ObjectsStore[ob_id]
  226.             assign_func = eval('cl.' + func_id[1])
  227.         elif res_obj:
  228.             FixDataBase.append((func_id, res_obj.ObjId, res_field, ob_id))
  229.         
  230.     elif func_kind == 'f':
  231.         assign_func = PickInit.ConstFunction(func_id[0], func_id[1])
  232.     elif func_kind == 'cf':
  233.         assign_func = PickInit.ConstCFunction(func_id[0])
  234.     elif func_kind == 'n':
  235.         assign_func = None
  236.     
  237.     if res_obj:
  238.         exec 'res_obj.' + res_field + '=assign_func'
  239.     else:
  240.         return assign_func
  241.  
  242.  
  243. def SaveEntityAux(ent):
  244.     if ent:
  245.         
  246.         try:
  247.             return ent.Name
  248.         except:
  249.             print 'Error getting entity name', ent
  250.             return None
  251.  
  252.     
  253.     return None
  254.  
  255.  
  256. def LoadEntityAux(ent_id):
  257.     if ent_id:
  258.         return Bladex.GetEntity(ent_id)
  259.     
  260.     return None
  261.  
  262.  
  263. def SaveExtraDataAux(file, aux_dir):
  264.     
  265.     try:
  266.         import ExtraData
  267.         filename = '%s/ExtraData.dat' % (aux_dir,)
  268.         if ExtraData.SaveExtraData(filename):
  269.             file.write('try:\n')
  270.             file.write('  GameStateAux.LoadExtraDataAux("%s")\n' % (filename,))
  271.             file.write('except:\n')
  272.             file.write('  print "Can not load ExtraData"\n\n')
  273.     except:
  274.         pass
  275.  
  276.  
  277.  
  278. def LoadExtraDataAux(filename):
  279.     import ExtraData
  280.     ExtraData.LoadExtraData(filename)
  281.  
  282.  
  283. def GetAllBases(check_class):
  284.     ret = []
  285.     bases = check_class.__bases__
  286.     for i in bases:
  287.         ret.append(i)
  288.         bases_i = GetAllBases(i)
  289.         for j in bases_i:
  290.             ret.append(j)
  291.         
  292.     
  293.     return ret
  294.  
  295.  
  296. def GetNewMembers(check_class):
  297.     '''Obtiene los miembros nuevos de la clase y de sus clases base'''
  298.     class_dict = { }
  299.     bases = GetAllBases(check_class.__class__)
  300.     for i in bases:
  301.         class_dict.update(i.__dict__)
  302.     
  303.     class_dict.update(check_class.__class__.__dict__)
  304.     check_dict = check_class.__dict__
  305.     new_members = { }
  306.     for j in check_dict.keys():
  307.         pass
  308.     
  309.     return new_members
  310.  
  311.  
  312. def SaveNewMembers(check_class):
  313.     if type(check_class) != types.InstanceType:
  314.         return ()
  315.     
  316.     ret = []
  317.     entity_type = type(Bladex.GetEntity(0))
  318.     members = GetNewMembers(check_class)
  319.     members_keys = members.keys()
  320.     for i in members_keys:
  321.         member = members[i]
  322.         member_t = type(member)
  323.         print check_class, i, member_t
  324.         if member_t == types.FunctionType or member_t == types.MethodType:
  325.             ret.append(('Function', i, SaveFunctionAux(member)))
  326.         elif member_t == entity_type:
  327.             ret.append(('Entity', i, SaveEntityAux(member)))
  328.         else:
  329.             ret.append(('Other', i, member))
  330.     
  331.     return tuple(ret)
  332.  
  333.  
  334. def LoadNewMembers(mod_class, new_members):
  335.     
  336.     try:
  337.         for i in new_members:
  338.             if i[0] == 'Function':
  339.                 LoadFunctionAux(i[2], mod_class, i[1])
  340.             elif i[1] == 'Entity':
  341.                 mod_class.__dict__[i[1]] = LoadEntityAux(i[2])
  342.             else:
  343.                 mod_class.__dict__[i[1]] = i[2]
  344.     except Exception:
  345.         exc = None
  346.         print 'LoadNewMembers() Error', exc, mod_class, new_members
  347.  
  348.  
  349.  
  350. def GetBaseMethod(check_class, method_name, bases):
  351.     for i in bases:
  352.         
  353.         try:
  354.             tmp_string = "i.__dict__['" + method_name + "']"
  355.             return eval(tmp_string)
  356.         except:
  357.             0
  358.             bases
  359.  
  360.     
  361.     return None
  362.  
  363.  
  364. def GetAlteredMethods(check_class):
  365.     '''Obtiene los metodos de una clase y de sus clases base que han sido cambiados'''
  366.     class_dict = { }
  367.     bases = GetAllBases(check_class.__class__)
  368.     for i in bases:
  369.         class_dict.update(i.__dict__)
  370.     
  371.     class_dict.update(check_class.__class__.__dict__)
  372.     altered_beast = { }
  373.     for j in class_dict.keys():
  374.         member = eval('check_class.' + j)
  375.         if type(member) == types.MethodType:
  376.             found_func = eval('member.im_func')
  377.             tmp_string = "check_class.__class__.__dict__['" + j + "']"
  378.             
  379.             try:
  380.                 reference_func = eval(tmp_string)
  381.             except:
  382.                 0
  383.                 class_dict.keys()
  384.                 0
  385.                 reference_func = GetBaseMethod(check_class, j, bases)
  386.  
  387.             if found_func != reference_func:
  388.                 altered_beast[j] = member
  389.             
  390.         
  391.     
  392.     return altered_beast
  393.  
  394.  
  395. def GetFunctionFile(f):
  396.     if not f:
  397.         return 'Error, None is not  a function'
  398.     
  399.     
  400.     try:
  401.         import string
  402.         s = str(f.func_code)
  403.         s2 = string.split(s, '"')
  404.         func_path = s2[1]
  405.         import os
  406.         filename = os.path.split(func_path)[1]
  407.         filename_noext = os.path.splitext(filename)[0]
  408.         return filename_noext
  409.     except e:
  410.         print 'Exception in GetFunctionFile', e
  411.         return 'Error getting lib'
  412.  
  413.  
  414.