diff --git a/evennia/scripts/scripts.py b/evennia/scripts/scripts.py index 24e25592fa..67367df3bb 100644 --- a/evennia/scripts/scripts.py +++ b/evennia/scripts/scripts.py @@ -141,15 +141,6 @@ class ScriptBase(with_metaclass(TypeclassBase, ScriptDB)): """ objects = ScriptManager() - -class DefaultScript(ScriptBase): - """ - This is the base TypeClass for all Scripts. Scripts describe - events, timers and states in game, they can have a time component - or describe a state that changes under certain conditions. - - """ - def __eq__(self, other): """ Compares two Scripts. Compares dbids. @@ -239,7 +230,96 @@ class DefaultScript(ScriptBase): logger.log_trace() return None - # Public methods + def at_script_creation(self): + """ + Should be overridden in child. + + """ + pass + + def at_first_save(self, **kwargs): + """ + This is called after very first time this object is saved. + Generally, you don't need to overload this, but only the hooks + called by this method. + + Args: + **kwargs (dict): Arbitrary, optional arguments for users + overriding the call (unused by default). + + """ + self.at_script_creation() + + if hasattr(self, "_createdict"): + # this will only be set if the utils.create_script + # function was used to create the object. We want + # the create call's kwargs to override the values + # set by hooks. + cdict = self._createdict + updates = [] + if not cdict.get("key"): + if not self.db_key: + self.db_key = "#%i" % self.dbid + updates.append("db_key") + elif self.db_key != cdict["key"]: + self.db_key = cdict["key"] + updates.append("db_key") + if cdict.get("interval") and self.interval != cdict["interval"]: + self.db_interval = cdict["interval"] + updates.append("db_interval") + if cdict.get("start_delay") and self.start_delay != cdict["start_delay"]: + self.db_start_delay = cdict["start_delay"] + updates.append("db_start_delay") + if cdict.get("repeats") and self.repeats != cdict["repeats"]: + self.db_repeats = cdict["repeats"] + updates.append("db_repeats") + if cdict.get("persistent") and self.persistent != cdict["persistent"]: + self.db_persistent = cdict["persistent"] + updates.append("db_persistent") + if cdict.get("desc") and self.desc != cdict["desc"]: + self.db_desc = cdict["desc"] + updates.append("db_desc") + if updates: + self.save(update_fields=updates) + + if cdict.get("permissions"): + self.permissions.batch_add(*cdict["permissions"]) + if cdict.get("locks"): + self.locks.add(cdict["locks"]) + if cdict.get("tags"): + # this should be a list of tags, tuples (key, category) or (key, category, data) + self.tags.batch_add(*cdict["tags"]) + if cdict.get("attributes"): + # this should be tuples (key, val, ...) + self.attributes.batch_add(*cdict["attributes"]) + if cdict.get("nattributes"): + # this should be a dict of nattrname:value + for key, value in cdict["nattributes"]: + self.nattributes.add(key, value) + + if not cdict.get("autostart"): + # don't auto-start the script + return + + # auto-start script (default) + self.start() + + +class DefaultScript(ScriptBase): + """ + This is the base TypeClass for all Scripts. Scripts describe + events, timers and states in game, they can have a time component + or describe a state that changes under certain conditions. + + """ + + def at_script_creation(self): + """ + Only called once, when script is first created. + + """ + pass + def time_until_next_repeat(self): """ @@ -472,77 +552,6 @@ class DefaultScript(ScriptBase): if task: task.force_repeat() - def at_first_save(self, **kwargs): - """ - This is called after very first time this object is saved. - Generally, you don't need to overload this, but only the hooks - called by this method. - - Args: - **kwargs (dict): Arbitrary, optional arguments for users - overriding the call (unused by default). - - """ - self.at_script_creation() - - if hasattr(self, "_createdict"): - # this will only be set if the utils.create_script - # function was used to create the object. We want - # the create call's kwargs to override the values - # set by hooks. - cdict = self._createdict - updates = [] - if not cdict.get("key"): - if not self.db_key: - self.db_key = "#%i" % self.dbid - updates.append("db_key") - elif self.db_key != cdict["key"]: - self.db_key = cdict["key"] - updates.append("db_key") - if cdict.get("interval") and self.interval != cdict["interval"]: - self.db_interval = cdict["interval"] - updates.append("db_interval") - if cdict.get("start_delay") and self.start_delay != cdict["start_delay"]: - self.db_start_delay = cdict["start_delay"] - updates.append("db_start_delay") - if cdict.get("repeats") and self.repeats != cdict["repeats"]: - self.db_repeats = cdict["repeats"] - updates.append("db_repeats") - if cdict.get("persistent") and self.persistent != cdict["persistent"]: - self.db_persistent = cdict["persistent"] - updates.append("db_persistent") - if updates: - self.save(update_fields=updates) - - if cdict.get("permissions"): - self.permissions.batch_add(*cdict["permissions"]) - if cdict.get("locks"): - self.locks.add(cdict["locks"]) - if cdict.get("tags"): - # this should be a list of tags, tuples (key, category) or (key, category, data) - self.tags.batch_add(*cdict["tags"]) - if cdict.get("attributes"): - # this should be tuples (key, val, ...) - self.attributes.batch_add(*cdict["attributes"]) - if cdict.get("nattributes"): - # this should be a dict of nattrname:value - for key, value in cdict["nattributes"]: - self.nattributes.add(key, value) - - if not cdict.get("autostart"): - # don't auto-start the script - return - - # auto-start script (default) - self.start() - - def at_script_creation(self): - """ - Only called once, by the create function. - - """ - pass - def is_valid(self): """ Is called to check if the script is valid to run at this time. diff --git a/evennia/utils/create.py b/evennia/utils/create.py index c5fb6f8416..36db7e5a60 100644 --- a/evennia/utils/create.py +++ b/evennia/utils/create.py @@ -101,6 +101,7 @@ def create_object(typeclass=None, key=None, location=None, home=None, locks = make_iter(locks) if locks is not None else None aliases = make_iter(aliases) if aliases is not None else None tags = make_iter(tags) if tags is not None else None + attributes = make_iter(attributes) if attributes is not None else None if isinstance(typeclass, basestring): @@ -177,7 +178,9 @@ def create_script(typeclass=None, key=None, obj=None, account=None, locks=None, created or if the `start` method must be called explicitly. report_to (Object): The object to return error messages to. desc (str): Optional description of script - + tags (list): List of tags or tuples (tag, category). + attributes (list): List if tuples (key, value) or (key, value, category) + (key, value, lockstring) or (key, value, lockstring, default_access). See evennia.scripts.manager for methods to manipulate existing scripts in the database. @@ -198,9 +201,9 @@ def create_script(typeclass=None, key=None, obj=None, account=None, locks=None, if key: kwarg["db_key"] = key if account: - kwarg["db_account"] = dbid_to_obj(account, _ScriptDB) + kwarg["db_account"] = dbid_to_obj(account, _AccountDB) if obj: - kwarg["db_obj"] = dbid_to_obj(obj, _ScriptDB) + kwarg["db_obj"] = dbid_to_obj(obj, _ObjectDB) if interval: kwarg["db_interval"] = interval if start_delay: @@ -211,6 +214,8 @@ def create_script(typeclass=None, key=None, obj=None, account=None, locks=None, kwarg["db_persistent"] = persistent if desc: kwarg["db_desc"] = desc + tags = make_iter(tags) if tags is not None else None + attributes = make_iter(attributes) if attributes is not None else None # create new instance new_script = typeclass(**kwarg) @@ -218,7 +223,8 @@ def create_script(typeclass=None, key=None, obj=None, account=None, locks=None, # store the call signature for the signal new_script._createdict = dict(key=key, obj=obj, account=account, locks=locks, interval=interval, start_delay=start_delay, repeats=repeats, persistent=persistent, - autostart=autostart, report_to=report_to) + autostart=autostart, report_to=report_to, desc=desc, + tags=tags, attributes=attributes) # this will trigger the save signal which in turn calls the # at_first_save hook on the typeclass, where the _createdict # can be used. diff --git a/evennia/utils/olc/olc_storage.py b/evennia/utils/olc/olc_storage.py index d64956f8a0..f96a79edb2 100644 --- a/evennia/utils/olc/olc_storage.py +++ b/evennia/utils/olc/olc_storage.py @@ -18,8 +18,9 @@ class PersistentPrototype(DefaultScript): """ This stores a single prototype """ - key = "persistent_prototype" - desc = "Stores a prototoype" + def at_script_creation(self): + self.key = "empty prototype" + self.desc = "A prototype" def store_prototype(caller, key, prototype, desc="", tags=None, locks="", delete=False): @@ -64,7 +65,7 @@ def store_prototype(caller, key, prototype, desc="", tags=None, locks="", delete if desc: stored_prototype.desc = desc if tags: - stored_prototype.tags.add(tags) + stored_prototype.tags.batch_add(*tags) if locks: stored_prototype.locks.add(locks) if prototype: @@ -95,12 +96,13 @@ def search_prototype(key=None, tags=None): be found. """ - matches = PersistentPrototype.objects.all() if tags: # exact match on tag(s) tags = make_iter(tags) - tag_categories = ("persistent_prototype" for _ in tags) - matches = matches.get_by_tag(tags, tag_categories) + tag_categories = ["persistent_prototype" for _ in tags] + matches = PersistentPrototype.objects.get_by_tag(tags, tag_categories) + else: + matches = PersistentPrototype.objects.all() if key: # partial match on key matches = matches.filter(db_key=key) or matches.filter(db_key__icontains=key) @@ -142,8 +144,8 @@ def get_prototype_list(caller, key=None, tags=None, show_non_use=False, show_non table = [] for i in range(len(prototypes[0])): - table.append([tup[i] for tup in prototypes]) - table = EvTable("Key", "Desc", "Use", "Edit", table, crop=True, width=78) + table.append([str(tup[i]) for tup in prototypes]) + table = EvTable("Key", "Desc", "Use", "Edit", table=table, crop=True, width=78) table.reformat_column(0, width=28) table.reformat_column(1, width=40) table.reformat_column(2, width=5)