apocalyptech
commented
6 years ago Actually, I suppose the following in the World class might be somewhat useful. It's still rather inefficient to have to loop through all the keys in the world, if you're just looking for a single entity, but something like this should do:
@property
def uuid_to_region_map(self):
"""
A dict whose keys are the UUIDs (or just IDs, in some
cases) of entities, and whose values are the `(rx, ry)`
coordinates in which that entity can be found.
"""
if not self._uuid_to_region_map:
self._uuid_to_region_map = {}
for key in self.get_all_keys():
(layer, rx, ry) = struct.unpack('>BHH', key)
if layer == 4:
stream = io.BytesIO(self.get(layer, rx, ry))
num_entities = struct.unpack('B', stream.read(1))[0]
for i in range(num_entities):
strlen = struct.unpack('B', stream.read(1))[0]
uuid = stream.read(strlen).decode('utf-8')
if uuid in self._uuid_to_region_map:
# TODO: err? Should we do this?
raise Exception('UUID {} found in two regions'.format(uuid))
else:
self._uuid_to_region_map[uuid] = (rx, ry)
return self._uuid_to_region_mapTwo things I'm unsure of with that:
- Should
utf-8be used for decoding? I suspect that they never get beyondlatin1. If they're not latin1, does the length value indicate the number of bytes or the number of characters? (I'd assume the former, but I'd also assume that the question's moot 'cause probably the IDs never get beyond ASCII.) - What should be done if the same UUID's found in more that one place?
Anyway, something like that would at least enable apps to do something like:
for mark in bookmarks:
if mark.uuid in world.uuid_to_region_map:
entities = world.get_entities(*world.uuid_to_region_map[mark.uuid])
for entity in entities:
if ('uniqueId' in entity.data and entity.data['uniqueId'] == mark.uuid):
(ex, ey) = entity.data['tilePosition']
print(' * Found bookmark "{}" in {}, at coords ({}, {})'.format(
mark.name,
filename,
ex,
ey
))
else:
print(' * Bookmark "{}" not found in {}'.format(
mark.name,
filename,
)) I could PR that function if it's something you think you might want in the project, though I admit that even better would be a way to figure out those layer-3 lookups so we're not looping through all keys.
blixt
I'm putting this one in here more for documentation and brainstorming than anything else, in case someone else feels like puzzling this out. I've got it Good Enough for my own purposes, and was planning on just implementing what I've got in my own app. It'd be nice to have a "real" API for this, though whether it's worth the work is another question.
Anyway, I wanted to find out how to find user bookmarks, though this seems to also be a method to (probably) find where any Entity is, based on UUID (though I haven't really looked into that too far). The starting point for bookmarks, at least, is in the player JSON data, underneath
universeMap.(uuid).teleportBookmarks, and includes the following data:The colon-separated string contains one of:
CelestialWorldentries point to theuniverse/*.worldfiles, as you'd expect,InstanceWorldentries point touniverse/unique-<filename_part>-<instance_uuid>-<suffix_num>.worldfiles, andClientShipWorldpoints toplayer/<player_uuid>.shipworld.Notably absent from that info is the actual world coordinates for the bookmark - for that we need to look at the map data itself. One brute-force way would be to loop through all regions,
get_entitieson them, and look for entities whoseuniqueIdattribute matches the bookmark UUID (and then use that entity'stilePosition).To avoid having to loop through all entities in the map, it looks like the map data types/layers 3 and 4 could be used. Layer 4 is the simplest, and seems to be a simple map of all entity UUIDs in a region, so you can get those with just
world.get(4, rx, ry), though of course finding that would require looping through all keys, since you don't know therx, ryyet. The data itself in there starts out with a single unsigned byte which is the number of IDs included in the data, and then a length-prefixed string for each ID (the length is another single unsigned byte - ordinarily0x20/32 for UUIDs).Layer 3 is a bit more complex, and I suspect that this is the one which is intended to be used for this sort of lookup. My first big unknown is that I have no idea what the key actually represents. The layer/type is 4, of course, but I've yet to figure out what in the world the other eight bytes are meant to describe. It's definitely not just
rx, ry, and may not even be considered two shorts.As for the data inside layer 3 nodes, it starts off with an unsigned short specifying the number of entries. Each entry starts out with a length-prefixed string, as with the layer 4 entry. Then there's two shorts which give you the region X, Y, and a further eight bytes I don't have a clue how to interpret.
So right now, for both of those layers, the best I can manage is looping through all the keys in the DB, matching on the UUID, and then using the region X,Y to grab entities in that region, and match on the UUID in there as well. I assume there's got to be a way to generate the keys for region 3 data using what exists in the Player bookmark data, but I've not figured that out yet. Among the things I tried was checking to see if the key happened to be a crc32 of the UUID, but no such luck there.
I know this is already super long-winded, but for thoroughness's sake, here's various bookmarks and their layer 3 keys/unknown data: