merge master

Author: El Sif

README.md

@@ -1,9 +1,6 @@
 # StarryPy
 
-StarryPy is Twisted-based plugin-driven Starbound server wrapper. It is currently
-in beta.
-
-**NOTE! Player warping is currently __broken__**
+StarryPy is Twisted-based plugin-driven Starbound server wrapper. It is currently in beta.
 
 ## Features
 
@@ -17,13 +14,13 @@ With the built-in plugins (which are removable):
 * Join/quit announcements.
 * And more.
 
-## Version 1.6 is here!
+## Version 1.7 is here!
 
-With this most recent release, we are compatible with the current release of Starbound (Upbeat Giraffe). Any bugs found in the process, please open an issue ticket, so we can squash them as quickly as possible.
+With this most recent release, we are compatible with the current release of Starbound (Pleased Giraffe - Protocol 691). Any bugs found in the process, please open an issue ticket, so we can squash them as quickly as possible.
 
 ## Upgrading from older versions of StarryPy
 
-StarryPy 1.5 is **NOT** backwards compatible with older versions. As unfortunate as it is, we suggest wiping your database, and starting fresh. It will save a lot of headaches in the long run.
+This version of StarryPy should be completely compatible with all version back to 1.5. If you run into any problems, please let us know.
 
 ## Installation
 

base_plugin.py

@@ -94,6 +94,9 @@ def on_environment_update(self, data):
     def on_entity_interact_result(self, data):
         return True
 
+    def on_update_tile_protection(self, data):
+        return True
+
     def on_modify_tile_list(self, data):
         return True
 
@@ -166,7 +169,7 @@ def on_status_effect_request(self, data):
     def on_update_world_properties(self, data):
         return True
 
-    def on_heartbeat(self, data):
+    def on_step_update(self, data):
         return True
 
     def on_connect_success(self, data):
@@ -256,6 +259,9 @@ def after_environment_update(self, data):
     def after_entity_interact_result(self, data):
         return True
 
+    def after_update_tile_protection(self, data):
+        return True
+
     def after_modify_tile_list(self, data):
         return True
 
@@ -328,7 +334,7 @@ def after_status_effect_request(self, data):
     def after_update_world_properties(self, data):
         return True
 
-    def after_heartbeat(self, data):
+    def after_step_update(self, data):
         return True
 
     def after_connect_success(self, data):

packets/packet_types.py

@@ -63,9 +63,10 @@ class Packets(IntEnum):
     HIT_REQUEST = 50
     DAMAGE_REQUEST = 51
     DAMAGE_NOTIFICATION = 52
-    CALL_SCRIPTED_ENTITY = 53
-    UPDATE_WORLD_PROPERTIES = 54
-    HEARTBEAT = 55
+    ENTITY_MESSAGE = 53
+    ENTITY_MESSAGE_RESPONSE = 54
+    UPDATE_WORLD_PROPERTIES = 55
+    STEP_UPDATE = 56
 
 
 class WarpActionType(IntEnum):
@@ -151,8 +152,8 @@ def _decode(self, obj, context):
                                                                   SBInt32("satellite"))
 
 warp_action = lambda name="warp_action": Struct(name,
-                                                Byte("type"),
-                                                Switch("warp_action_type", lambda ctx: ctx["type"],
+                                                Byte("warp_type"),
+                                                Switch("warp_action_type", lambda ctx: ctx["warp_type"],
                                                        {
                                                            1 : LazyBound("next", lambda: warp_world),
                                                            2 : HexAdapter(Field("uuid", 16)),
@@ -206,6 +207,30 @@ def _decode(self, obj, context):
                             HexAdapter(Field("instance", 16))
                             )
 
+
+warp_touniqueworld_write = lambda name="warp_touniqueworld_write": Struct(name,
+                                                                          Byte("warp_type"),
+                                                                          Byte("world_type"),
+                                                                          star_string("unique_world_name"),
+                                                                          Byte("has_position"))
+
+warp_toplayerworld_write = lambda name="warp_toplayerworld_write": Struct(name,
+                                                                          Byte("warp_type"),
+                                                                          Byte("world_type"),
+                                                                          HexAdapter(Field("uuid", 16)),
+                                                                          Byte("has_position"))
+
+warp_toplayer_write = lambda name="warp_toplayer_write": Struct(name,
+                                                                Byte("warp_type"),
+                                                                HexAdapter(Field("uuid", 16))
+                                                                )
+
+warp_toalias_write = lambda name="warp_toalias_write": Struct(name,
+                                                              Byte("warp_type"),
+                                                              SBInt32("alias")
+                                                              )
+
+
 projectile = DictVariant("projectile")
 
 # ---------------------------------------
@@ -299,45 +324,40 @@ def _decode(self, obj, context):
             send_mode=send_mode))
 
 # (12) - PlayerWarp
-#player_warp = lambda name="player_warp": Struct(name,
-#                                                  Enum(UBInt8("warp_type"),
-#                                                       WARP_TO=0,
-#                                                       WARP_RETURN=1,
-#                                                       WARP_TO_HOME_WORLD=2,
-#                                                       WARP_TO_ORBITED_WORLD=3,
-#                                                       WARP_TO_OWN_SHIP=4),
-#                                                  WarpVariant("world_id"))
 player_warp = lambda name="player_warp": Struct(name,
                                                 warp_action())
 
-# (8) - PlayerWarpResult
-player_warp_result = lambda name="player_warp_result": Struct(name,
-                                                              Flag("success"),
-                                                              warp_action(),
-                                                              Flag("warp_action_invalid"))
-
-#player_warp_write = lambda t, world_id: player_warp().build(
-#    Container(
-#        warp_type=t,
-#        world_id=world_id))
-
-player_warp_toworld_write = lambda world_type, destination: player_warp().build(
+player_warp_touniqueworld_write = lambda destination: warp_touniqueworld_write().build(
     Container(
-        warp_action_type=1,
-        world_type=world_type,
-        unique_world_name=destination
+        warp_type=1,
+        world_type=1,
+        unique_world_name=destination,
+        has_position=0
     ))
-player_warp_toplayer_write = lambda uuid: player_warp().build(
+player_warp_toplayerworld_write = lambda destination: warp_toplayerworld_write().build(
     Container(
-        warp_action_type=2,
+        warp_type=1,
+        world_type=3,
+        uuid=destination,
+        has_position=0
+    ))
+player_warp_toplayer_write = lambda uuid: warp_toplayer_write().build(
+    Container(
+        warp_type=2,
         uuid=uuid
     ))
-player_warp_toalias_write = lambda alias: player_warp().build(
+player_warp_toalias_write = lambda alias: warp_toalias_write().build(
     Container(
-        warp_action_type=3,
+        warp_type=3,
         alias=alias
     ))
 
+# (8) - PlayerWarpResult
+player_warp_result = lambda name="player_warp_result": Struct(name,
+                                                              Flag("success"),
+                                                              warp_action(),
+                                                              Flag("warp_action_invalid"))
+
 # (13) - FlyShip
 fly_ship = lambda name="fly_ship": Struct(name,
                                           celestial_coordinate())
@@ -368,6 +388,9 @@ def _decode(self, obj, context):
                                                              If(lambda ctx: ctx["a"] == 0,
                                                                 Struct("junk",
                                                                        Padding(1),
+                                                                       Peek(Byte("b")),
+                                                                       If(lambda ctx: ctx["b"] == 0,
+                                                                           Padding(1)),
                                                                        VLQ("extra_length"))),
                                                              If(lambda ctx: ctx["a"] > 8,
                                                                 Struct("junk2",
@@ -436,6 +459,22 @@ def _decode(self, obj, context):
                                                                           Byte("variant_type"),
                                                                           GreedyRange(StarByteArray("item_description")))
 
+# (29) - UpdateTileProtection
+update_tile_protection = lambda name="update_tile_protection": Struct(name,
+                                                                      GreedyRange(
+                                                                          Struct("dungeon_block",
+                                                                                 UBInt16("dungeon_id"),
+                                                                                 Flag("is_protected"))))
+
+update_tile_protection_writer = lambda name="update_tile_protection_writer": Struct(name,
+                                                                                    UBInt16("dungeon_id"),
+                                                                                    Byte("is_protected"))
+
+update_tile_protection_write = lambda dungeon_id, is_protected: update_tile_protection_writer().build(
+        Container(
+            dungeon_id=dungeon_id,
+            is_protected=is_protected))
+
 # (36) - SpawnEntity
 spawn_entity = lambda name="spawn_entity": Struct(name,
                                                   GreedyRange(
@@ -507,7 +546,7 @@ def _decode(self, obj, context):
                                                                 star_string("target_material"),
                                                                 Flag("killed"))
 
-# (54) - UpdateWorldProperties
+# (55) - UpdateWorldProperties
 update_world_properties = lambda name="world_properties": Struct(name,
                                                                  UBInt8("count"),
                                                                  Array(lambda ctx: ctx.count,
@@ -520,6 +559,6 @@ def _decode(self, obj, context):
         count=len(dictionary),
         properties=[Container(key=k, value=Container(type="SVLQ", data=v)) for k, v in dictionary.items()]))
 
-# (55) - Heartbeat
-heartbeat = lambda name="heartbeat": Struct(name,
-                                            VLQ("remote_step"))
+# (56) - StepUpdate
+step_update = lambda name="step_update": Struct(name,
+                                                VLQ("remote_step"))

plugins/announcer_plugin/announcer_plugin.py

@@ -12,18 +12,9 @@ def activate(self):
         super(Announcer, self).activate()
 
     def after_connect_success(self, data):
-        try:
-            c = connect_success().parse(data.data)
-            if c.success:
-                self.factory.broadcast(
-                    self.protocol.player.colored_name(self.config.colors) + " logged in.", 0, "Announcer")
-        except AttributeError:
-            return
-        except:
-            self.logger.exception("Unknown error in after_connect_success.")
-            return
+        c = connect_success().parse(data.data)
+        self.factory.broadcast(self.protocol.player.colored_name(self.config.colors) + " logged in.", 0, "Announcer")
 
     def on_client_disconnect_request(self, data):
         if self.protocol.player is not None:
-            self.factory.broadcast(self.protocol.player.colored_name(self.config.colors) + " logged out.", 0,
-                                   "Announcer")
+            self.factory.broadcast(self.protocol.player.colored_name(self.config.colors) + " logged out.", 0, "Announcer")

plugins/backups_plugin/README.md

@@ -0,0 +1,44 @@
+# StarryPy Planetary Backup System
+---
+
+A StarryPy module for managing automated planet backups.
+
+## Contents
+
+- `backups_plugin.py` - The StarryPy plugin for managing planetary backups
+- `backuper.py` - The file-system script for implementing automated backups
+- `database.py` - Library file for handling connecting and managing the backups database.
+- `__init__.py` - Standard python junk.
+
+## In-game Commands
+
+All the following are sub-commands for the master `/backup` command. Hence, your command might look like:
+```
+/backup add Kharidiron home_planet
+```
+
+- `help` - Shows the basic help information
+- `add` - Adds a planet to the backups system. Requires an owner and a planet nick-name. Additionally, you must be standing on the planet to-be-backed-up.
+- `drop` - Removes a planet from the backups system. Requires an owner and a planet nick-name.
+- `manual` - Create a manual backup of a planet. Useful if you just completed a big project. You must be standing on the planet to use it, or you must supply the owner and the planet name.
+- `restore` - Restore a planet from a backup. You must provide an owner, a planet name, and a valid backup timestamp of the form `yyyy-mm-ddThh:mm`. That is a capital T in between. Also, no one should be on the planet's surface when the restore is attempted, as the planet file needs to be unlocked in order for the restore to work.
+- `enable` - Enable a planet's backups in the automated backup system. An owner and planet name must be provided.
+- `disable` - Disable a planet's backups in the automated backup system. An owner and planet name must be provided. This does not delete the planet, it simply turns off the automated backup.
+- `list` - Show all planets being backed up. If a name is provided, list all backups for that particular user. The users themselves can use this command to see what backups they own (but no one else's).
+- `status` - The status of a particular planet's backups, including all available timestamps. Either the owner and planet name must be provided, or you must be standing on the planet to use.
+
+## Notes
+
+### Windows...
+This script collecting was designed for Unix style systems. I do not plan to translate this for Windows systems, since the Windows OS enforces hard file locking, preventing the ability to restore planets gracefully. Sorry folks.
+
+### Crontab...
+In order to make use of the automated backup system, you will need to do two things:
+
+1. Setup a crontab entry to run the script at a regular interval. Here is a copy of mine:
+```
+0 */4 * * * /home/starbound/Starbound/StarryPy/plugins/backups_plugin/backuper.py
+```
+This runs the backup process once ever four hours, starting at midnight.
+
+2. Edit the file `backuper.py` and set the `UNIVERSE_PATH` variable to point to the location of your Starbound universe directory. Also consider editing the `NUM_TO_KEEP` value to what seems appropriate for your storage and environment. At one backup every four hours, that is six backups a day... or 42 backups a week. Choose what you deem fit.

plugins/backups_plugin/__init__.py

@@ -0,0 +1 @@
+from backups_plugin import BackupsPlugin