def register_obj_type(self, obj_cls=None, name=None, open=[], req=[]):
if obj_cls is None:
assert name is not None, 'Must provide either a name or class'
obj_cls = GameObject
elif name is None:
name = obj_cls.__name__
self.obj_types[name] = tdict(obj_cls=obj_cls,
open=tset(open),
req=tset(req))
def unjsonify(obj, tfm=None):
'''
Convert from a json readable python data structure (containing dict, list, tuples, humpack objects etc.)
to a json conpatible object (only dicts, lists, and primitives).
:param obj: Input data structure to be unjsonified
:param tfm: Custom transform function to unjsonify certain data structures (use with caution)
'''
if tfm is not None:
try:
return tfm(obj, unjsonify)
except UnknownElementError:
pass
if isinstance(obj, primitive):
return obj
if isinstance(obj, list):
return tlist([unjsonify(o, tfm=tfm) for o in obj])
if isinstance(obj, dict):
if len(obj) == 1 and '_tuple' in obj:
return tuple(unjsonify(o, tfm=tfm) for o in obj['_tuple'])
if len(obj) == 1 and '_set' in obj:
return tset(unjsonify(o, tfm=tfm) for o in obj['_set'])
if len(obj) == 2 and '_ndarray' in obj and '_dtype' in obj:
return np.array(unjsonify(obj['_ndarray'], tfm=tfm),
dtype=obj['_dtype'])
return tdict({k: unjsonify(v, tfm=tfm) for k, v in obj.items()})
raise UnknownElementError(obj)
def reset(self, ctrl):
game_info = ctrl._view_info()
types = game_info['player_types']
default = None
for name, info in types.items():
self.meta_info[name] = tdict(info)
if 'open' not in self.meta_info[
name] or self.meta_info[name].open is None:
self.meta_info[name].open = tset()
if not self.hide_name:
self.meta_info[name].open.add('name')
if 'default' in info and info['default']:
default = name
if default is None:
if len(self.meta_info) == 1:
default = next(iter(self.meta_info))
else:
raise Exception('no default player type provided')
self.default_player = default
# by default only show player type if there is more than one type registered
self.show_player_type = len(
self.meta_info) > 1 or self.force_player_type
def create(self, obj_type, visible=None, ID=None, **props):
if obj_type in self.obj_types:
info = self.obj_types[obj_type]
else:
raise MissingObjectError(obj_type)
if ID is None:
ID = self.get_ID()
elif ID in self.table:
raise ObjectIDCollisionError(ID)
if visible is None:
visible = self.players
obj = info.obj_cls.__new__(info.obj_cls)
obj._id = ID
obj._table = self
obj._open = info.open
obj._req = info.req
obj.__init__(obj_type=obj_type, visible=tset(visible), **props)
self.table[obj._id] = obj
# obj._verify()
return obj
def __init__(self,
addr,
*users,
seed=None,
full_log=False,
god_mode=False):
self.addr = addr
self.full_log = full_log
self.god_mode = god_mode
self.rng = RandomGenerator()
if seed is None:
seed = random.getrandbits(64)
self.rng.seed(seed)
self.seed = seed
self.in_progress = False
self.msg = None
self.log = None
self.key = None
self.actions = None
self.users = tdeque(users)
self.user2players = tdict()
self.players = tdict()
self.specs = tset()
def begin(self, name, desc=None):
if self.in_transaction():
return
# assert name is not None, 'must specify a name'
self.set_name(name)
self.set_desc(desc)
self._current = tset()
def test_init(): ''' Test creating some standard humpack objects ''' x = tdict() assert len(x) == 0 x = tlist() assert len(x) == 0 x = tset() assert len(x) == 0
def get_tdict():
x = tdict()
x.a = 1
x.x = x
x.l = [tlist(), tset()]
x[100] = '100'
x[None] = 1.2
x.m = None
x[True] = tlist
x[list] = complex
x['<>)dksfl_ ds: gkal'] = '<>1234543224'
x['d = ds=a _+ sd;'] = bytes(range(256))
x[12.2344 + .023j] = range(123, 456, 7)
# np.random.seed(1)
# x.b = np.random.randn(3).tobytes()
x[b'\xaa'] = 'running'
return x
def process_actions(
raw
): # process input when saving new action set (mostly turn options into ActionElement instances)
if isinstance(raw, tuple):
return tuple(process_actions(r) for r in raw)
if isinstance(raw, set):
return tset(process_actions(r) for r in raw)
if isinstance(raw, ActionElement):
return raw
if isinstance(raw, GameObject):
return ObjectAction(raw)
if isinstance(raw, GamePlayer):
return PlayerAction(raw)
if isinstance(raw, (str, int, float, bool)):
return FixedAction(raw)
if type(raw).__module__ == 'numpy': # unwrap numpy types
return process_actions(raw.item())
raise UnknownActionElement(raw)
def decode_action_set(code):
code = _expand_actions(code)
return tset(map(_flatten, code))
