Fix broken get_flatland().

[plomrogue2] / plomrogue / game.py

diff --git a/plomrogue/game.py b/plomrogue/game.py
index 64ae6898a9f9c11d56506d37f114d3e997585af0..aa5c0db902ed9beda89ffe9f2dba8d9840170d73 100755 (executable)
--- a/plomrogue/game.py
+++ b/plomrogue/game.py
@@ -1,10 +1,9 @@
-from plomrogue.tasks import (Task_WAIT, Task_MOVE, Task_WRITE,
-                             Task_FLATTEN_SURROUNDINGS)

 from plomrogue.errors import GameError, PlayError
 from plomrogue.io import GameIO
 from plomrogue.misc import quote
 from plomrogue.mapping import YX, MapGeometrySquare, MapGeometryHex, Map
 import string
 from plomrogue.errors import GameError, PlayError
 from plomrogue.io import GameIO
 from plomrogue.misc import quote
 from plomrogue.mapping import YX, MapGeometrySquare, MapGeometryHex, Map
 import string

+import datetime

 
 
 
 
 
 


@@ -13,7 +12,7 @@ class GameBase:
     def __init__(self):
         self.turn = 0
         self.things = []
     def __init__(self):
         self.turn = 0
         self.things = []

-        self.map_geometry = MapGeometrySquare(YX(24, 40))
+        self.map_geometry = MapGeometrySquare(YX(32, 32))

         self.commands = {}
 
     def get_thing(self, id_):
         self.commands = {}
 
     def get_thing(self, id_):


@@ -60,15 +59,15 @@ class SaveableMap(Map):
             self.set_line(3, 'X' * self.geometry.size.x)
             self.set_line(4, 'X' * self.geometry.size.x)
             for y in range(self.geometry.size.y):
             self.set_line(3, 'X' * self.geometry.size.x)
             self.set_line(4, 'X' * self.geometry.size.x)
             for y in range(self.geometry.size.y):

-                self[YX(y,0)] = 'X'
-                self[YX(y,1)] = 'X'
-                self[YX(y,2)] = 'X'
-                self[YX(y,3)] = 'X'
-                self[YX(y,4)] = 'X'
+                self[YX(y, 0)] = 'X'
+                self[YX(y, 1)] = 'X'
+                self[YX(y, 2)] = 'X'
+                self[YX(y, 3)] = 'X'
+                self[YX(y, 4)] = 'X'

         elif type(self.geometry) == MapGeometryHex:
             # TODO: for this to work we need a map side length divisible by 6.
 
         elif type(self.geometry) == MapGeometryHex:
             # TODO: for this to work we need a map side length divisible by 6.
 

-            def draw_grid(offset=YX(0,0)):
+            def draw_grid(offset=YX(0, 0)):

                 dirs = ('DOWNRIGHT', 'RIGHT', 'UPRIGHT', 'RIGHT')
 
                 def draw_snake(start):
                 dirs = ('DOWNRIGHT', 'RIGHT', 'UPRIGHT', 'RIGHT')
 
                 def draw_snake(start):


@@ -91,20 +90,23 @@ class SaveableMap(Map):
 
                 if alternate_hex:
                     draw_snake(offset + YX(0, 0))
 
                 if alternate_hex:
                     draw_snake(offset + YX(0, 0))

-                draw_snake(offset + YX((0 + alternate_hex) * distance, -int(1.5*distance)))
-                draw_snake(offset + YX((1 + alternate_hex) * distance, 0))
-                draw_snake(offset + YX((2 + alternate_hex) * distance, -int(1.5*distance)))
+                draw_snake(offset + YX((0 + alternate_hex) * distance,
+                           -int(1.5 * distance)))
+                draw_snake(offset + YX((1 + alternate_hex) * distance,
+                           0))
+                draw_snake(offset + YX((2 + alternate_hex) * distance,
+                           -int(1.5 * distance)))

 
             distance = self.geometry.size.y // 3
             draw_grid()
 
             distance = self.geometry.size.y // 3
             draw_grid()

-            draw_grid(YX(2,0))
-            draw_grid(YX(0,2))
-            draw_grid(YX(1,0))
-            draw_grid(YX(0,1))
-            draw_grid(YX(-1,0))
-            draw_grid(YX(0,-1))
-            draw_grid(YX(-2,0))
-            draw_grid(YX(0,-2))
+            draw_grid(YX(2, 0))
+            draw_grid(YX(0, 2))
+            draw_grid(YX(1, 0))
+            draw_grid(YX(0, 1))
+            draw_grid(YX(-1, 0))
+            draw_grid(YX(0, -1))
+            draw_grid(YX(-2, 0))
+            draw_grid(YX(0, -2))

         self.modified = old_modified
 
 
         self.modified = old_modified
 
 


@@ -113,31 +115,34 @@ import os
 class Game(GameBase):
 
     def __init__(self, save_file, *args, **kwargs):
 class Game(GameBase):
 
     def __init__(self, save_file, *args, **kwargs):

+        from plomrogue.misc import Terrain

         super().__init__(*args, **kwargs)
         self.changed = True
         super().__init__(*args, **kwargs)
         self.changed = True

+        self.changed_tiles = []

         self.io = GameIO(self, save_file)
         self.tasks = {}
         self.thing_types = {}
         self.sessions = {}
         self.io = GameIO(self, save_file)
         self.tasks = {}
         self.thing_types = {}
         self.sessions = {}

+        self.faces = {}
+        self.hats = {}

         self.maps = {}
         self.map_controls = {}
         self.map_control_passwords = {}
         self.annotations = {}
         self.maps = {}
         self.map_controls = {}
         self.map_control_passwords = {}
         self.annotations = {}

-        self.spawn_point = YX(0,0), YX(0,0)
+        self.spawn_point = YX(0, 0), YX(0, 0)

         self.portals = {}
         self.player_chars = string.digits + string.ascii_letters
         self.player_char_i = -1
         self.admin_passwords = []
         self.portals = {}
         self.player_chars = string.digits + string.ascii_letters
         self.player_char_i = -1
         self.admin_passwords = []

+        self.send_gamestate_interval = datetime.timedelta(seconds=0.04)
+        self.last_send_gamestate = datetime.datetime.now() -\
+            self.send_gamestate_interval

         self.terrains = {
         self.terrains = {

-            '.': 'floor',
-            'X': 'wall',
-            '=': 'window',
-            '#': 'bed',
-            'T': 'desk',
-            '8': 'cupboard',
-            '[': 'glass door',
-            'o': 'sink',
-            'O': 'toilet'
+            '.': Terrain('.', 'floor'),
+            'X': Terrain('X', 'wall', blocks_light=True, blocks_sound=True,
+                         blocks_movement=True),
+            '=': Terrain('=', 'glass', blocks_sound=True, blocks_movement=True),
+            'T': Terrain('T', 'table', blocks_movement=True),

         }
         if os.path.exists(self.io.save_file):
             if not os.path.isfile(self.io.save_file):
         }
         if os.path.exists(self.io.save_file):
             if not os.path.isfile(self.io.save_file):


@@ -158,6 +163,12 @@ class Game(GameBase):
                 print("FILE INPUT LINE %5s: %s" % (i, line), end='')
                 self.io.handle_input(line, god_mode=True)
 
                 print("FILE INPUT LINE %5s: %s" % (i, line), end='')
                 self.io.handle_input(line, god_mode=True)
 

+    def can_do_thing_with_pw(self, thing, pw):
+        if thing.protection in self.map_control_passwords.keys():
+            if pw != self.map_control_passwords[thing.protection]:
+                return False
+        return True
+

     def can_do_tile_with_pw(self, big_yx, little_yx, pw):
         map_control = self.get_map(big_yx, 'control')
         tile_class = map_control[little_yx]
     def can_do_tile_with_pw(self, big_yx, little_yx, pw):
         map_control = self.get_map(big_yx, 'control')
         tile_class = map_control[little_yx]


@@ -169,7 +180,9 @@ class Game(GameBase):
 
     def get_string_options(self, string_option_type):
         if string_option_type == 'direction':
 
     def get_string_options(self, string_option_type):
         if string_option_type == 'direction':

-            return self.map_geometry.get_directions()
+            return self.map_geometry.directions
+        elif string_option_type == 'direction+here':
+            return ['HERE'] + self.map_geometry.directions

         elif string_option_type == 'char':
             return [c for c in
                     string.digits + string.ascii_letters + string.punctuation + ' ']
         elif string_option_type == 'char':
             return [c for c in
                     string.digits + string.ascii_letters + string.punctuation + ' ']


@@ -183,45 +196,133 @@ class Game(GameBase):
         return self.map_geometry.__class__.__name__[len('MapGeometry'):]
 
     def get_player(self, connection_id):
         return self.map_geometry.__class__.__name__[len('MapGeometry'):]
 
     def get_player(self, connection_id):

-        if not connection_id in self.sessions:
+        if connection_id not in self.sessions:

             return None
         player = self.get_thing(self.sessions[connection_id]['thing_id'])
         return player
 
             return None
         player = self.get_thing(self.sessions[connection_id]['thing_id'])
         return player
 

+    def get_face(self, t):
+        if t.type_ == 'Player':
+            if t.name in self.faces:
+                return self.faces[t.name]
+            else:
+                return '/O  O\\' + '| oo |' + '\\>--</'
+        return None
+
+    def remove_thing(self, t):
+        if t.carrying:
+            t.uncarry()
+        self.things.remove(t)
+        self.record_fov_change(t.position)
+
+    def add_thing(self, type_, position, id_=0):
+        t_old = None
+        if id_ > 0:
+            t_old = self.get_thing(id_)
+        t = self.thing_types[type_](self, id_=id_, position=position)
+        if t_old:
+            self.things[self.things.index(t_old)] = t
+        else:
+            self.things += [t]
+        self.record_fov_change(t.position)
+        return t
+

     def send_gamestate(self, connection_id=None):
         """Send out game state data relevant to clients."""
 
     def send_gamestate(self, connection_id=None):
         """Send out game state data relevant to clients."""
 

-        self.io.send('TURN ' + str(self.turn))
-        for c_id in self.sessions:
+        # TODO: limit to connection_id if provided
+        from plomrogue.mapping import FovMap
+        import multiprocessing
+        if connection_id:
+            c_ids = [connection_id]
+        else:
+            c_ids = [c_id for c_id in self.sessions]
+        # Only recalc FOVs for players with ._fov = None
+        player_fovs = []
+        player_fov_ids = []
+        for c_id in c_ids:

             player = self.get_player(c_id)
             player = self.get_player(c_id)

-            visible_terrain = player.fov_stencil_map()
-            self.io.send('FOV %s' % quote(player.fov_stencil.terrain), c_id)
-            self.io.send('MAP %s %s %s' % (self.get_map_geometry_shape(),
-                                           player.fov_stencil.geometry.size,
-                                           quote(visible_terrain)), c_id)
-            visible_control = player.fov_stencil_map('control')
-            self.io.send('MAP_CONTROL %s' % quote(visible_control), c_id)
-            for t in [t for t in self.things if player.fov_test(*t.position)]:
-                target_yx = player.fov_stencil.target_yx(*t.position)
-                self.io.send('THING %s %s %s' % (target_yx, t.type_, t.id_), c_id)
-                if hasattr(t, 'name'):
-                    self.io.send('THING_NAME %s %s' % (t.id_, quote(t.name)), c_id)
-                if hasattr(t, 'player_char'):
-                    self.io.send('THING_CHAR %s %s' % (t.id_,
-                                                       quote(t.player_char)), c_id)
-            for big_yx in self.portals:
-                for little_yx in [little_yx for little_yx in self.portals[big_yx]
-                                  if player.fov_test(big_yx, little_yx)]:
-                    target_yx = player.fov_stencil.target_yx(big_yx, little_yx)
-                    portal = self.portals[big_yx][little_yx]
-                    self.io.send('PORTAL %s %s' % (target_yx, quote(portal)), c_id)
-            for big_yx in self.annotations:
-                for little_yx in [little_yx for little_yx in self.annotations[big_yx]
-                                  if player.fov_test(big_yx, little_yx)]:
-                    target_yx = player.fov_stencil.target_yx(big_yx, little_yx)
-                    annotation = self.annotations[big_yx][little_yx]
-                    self.io.send('ANNOTATION_HINT %s' % (target_yx,), c_id)
-        self.io.send('GAME_STATE_COMPLETE')
+            if player._fov:
+                continue
+            player.prepare_multiprocessible_fov_stencil()
+            player_fovs += [player._fov]
+            player_fov_ids += [player.id_]
+        new_fovs = []
+        single_core_until = 16  # since multiprocess has its own overhead
+        if len(player_fovs) > single_core_until:
+            pool = multiprocessing.Pool()
+            new_fovs = pool.map(FovMap.init_terrain, [fov for fov in player_fovs])
+            pool.close()
+            pool.join()
+        elif len(player_fovs) <= single_core_until:
+            for fov in player_fovs:
+                new_fovs += [fov.init_terrain()]
+        for i in range(len(player_fov_ids)):
+            id_ = player_fov_ids[i]
+            player = self.get_thing(id_)
+            player._fov = new_fovs[i]
+        for c_id in c_ids:
+            self.io.send('TURN ' + str(self.turn), c_id)
+            player = self.get_player(c_id)
+            if player.id_ in player_fov_ids:
+                self.io.send('FOV %s' % quote(player.fov_stencil.terrain), c_id)
+                self.io.send('MAP %s %s %s' % (self.get_map_geometry_shape(),
+                                               player.fov_stencil.geometry.size,
+                                               quote(player.visible_terrain)), c_id)
+                self.io.send('MAP_CONTROL %s' % quote(player.visible_control), c_id)
+            if player.id_ in player_fov_ids:
+                # FIXME: Many of the following updates are triggered by technically
+                # inappropriate calls to game.record_fov_change, since they depict
+                # states that might change independent of FOV changes.  They are
+                # collected here as a shortcut, but a cleaner way would be to
+                # differentiate the changes somehow.
+                self.io.send('PSEUDO_FOV_WIPE', c_id)
+                for t in player.seen_things:
+                    target_yx = player.fov_stencil.target_yx(*t.position)
+                    self.io.send('THING %s %s %s %s %s %s'
+                                 % (target_yx, t.type_, quote(t.protection), t.id_,
+                                    int(t.portable), int(t.commandable)),
+                                 c_id)
+                    if hasattr(t, 'name'):
+                        self.io.send('THING_NAME %s %s' % (t.id_, quote(t.name)), c_id)
+                        if t.type_ == 'Player' and t.name in self.hats:
+                            hat = self.hats[t.name]
+                            self.io.send('THING_HAT %s %s' % (t.id_, quote(hat)), c_id)
+                    face = self.get_face(t)
+                    if face:
+                        self.io.send('THING_FACE %s %s' % (t.id_, quote(face)), c_id)
+                    if hasattr(t, 'thing_char'):
+                        self.io.send('THING_CHAR %s %s' % (t.id_,
+                                                           quote(t.thing_char)), c_id)
+                    if hasattr(t, 'installable') and not t.portable:
+                        self.io.send('THING_INSTALLED %s' % (t.id_), c_id)
+                    if hasattr(t, 'design'):
+                        self.io.send('THING_HAT %s %s' % (t.id_,
+                                                          quote(t.design)), c_id)
+                for t in [t for t in player.seen_things if t.carrying]:
+                    # send this last so all carryable things are already created
+                    self.io.send('THING_CARRYING %s %s' % (t.id_, t.carrying.id_),
+                                 c_id)
+                for big_yx in self.portals:
+                    for little_yx in [little_yx for little_yx in self.portals[big_yx]
+                                      if player.fov_test(big_yx, little_yx)]:
+                        target_yx = player.fov_stencil.target_yx(big_yx, little_yx)
+                        portal = self.portals[big_yx][little_yx]
+                        self.io.send('PORTAL %s %s' % (target_yx, quote(portal)), c_id)
+                for big_yx in self.annotations:
+                    for little_yx in [little_yx for little_yx in self.annotations[big_yx]
+                                      if player.fov_test(big_yx, little_yx)]:
+                        target_yx = player.fov_stencil.target_yx(big_yx, little_yx)
+                        annotation = self.annotations[big_yx][little_yx]
+                        self.io.send('ANNOTATION %s %s' % (target_yx,
+                                                           quote(annotation)), c_id)
+            self.io.send('GAME_STATE_COMPLETE', c_id)
+
+    def record_fov_change(self, position):
+        big_yx, little_yx = position
+        self.changed_tiles += [self.map_geometry.undouble_yxyx(big_yx,
+                                                               little_yx)]
+        self.changed = True

 
     def run_tick(self):
         to_delete = []
 
     def run_tick(self):
         to_delete = []


@@ -235,11 +336,11 @@ class Game(GameBase):
                 t = self.get_player(connection_id)
                 if hasattr(t, 'name'):
                     self.io.send('CHAT ' + quote(t.name + ' left the map.'))
                 t = self.get_player(connection_id)
                 if hasattr(t, 'name'):
                     self.io.send('CHAT ' + quote(t.name + ' left the map.'))

-                self.things.remove(t)
+                self.remove_thing(t)

                 to_delete += [connection_id]
         for connection_id in to_delete:
             del self.sessions[connection_id]
                 to_delete += [connection_id]
         for connection_id in to_delete:
             del self.sessions[connection_id]

-            self.changed = True
+            # self.changed = True  already handled by remove_thing

         for t in [t for t in self.things]:
             if t in self.things:
                 try:
         for t in [t for t in self.things]:
             if t in self.things:
                 try:


@@ -254,9 +355,35 @@ class Game(GameBase):
                         self.io.send('PLAY_ERROR ' + quote(str(e)), connection_id)
         if self.changed:
             self.turn += 1
                         self.io.send('PLAY_ERROR ' + quote(str(e)), connection_id)
         if self.changed:
             self.turn += 1

-            self.send_gamestate()
-            self.changed = False
-            self.save()
+            # send_gamestate() can be rather expensive, due to among other reasons
+            # re-calculating players' FOVs, so don't send it out too often
+            if self.last_send_gamestate < \
+               datetime.datetime.now() -self.send_gamestate_interval:
+                if len(self.changed_tiles) > 0:
+                    for t in [t for t in self.things if t.type_ == 'Player']:
+                        fov_radius = 12  # TODO: un-hardcode
+                        absolute_position =\
+                            self.map_geometry.undouble_yxyx(t.position[0],
+                                                            t.position[1])
+                        y_range_start = absolute_position.y - fov_radius
+                        y_range_end = absolute_position.y + fov_radius
+                        x_range_start = absolute_position.x - fov_radius
+                        x_range_end = absolute_position.x + fov_radius
+                        # TODO: refactor with SourcedMap.inside?
+                        for position in self.changed_tiles:
+                            if position.y < y_range_start\
+                               or position.y > y_range_end:
+                                continue
+                            if position.x < x_range_start\
+                               or position.x > x_range_end:
+                                continue
+                            t.invalidate_map_view()
+                            break
+                self.send_gamestate()
+                self.changed = False
+                self.changed_tiles = []
+                self.save()
+                self.last_send_gamestate = datetime.datetime.now()

 
     def get_command(self, command_name):
 
 
     def get_command(self, command_name):
 


@@ -301,49 +428,99 @@ class Game(GameBase):
             self.player_char_i = 0
         return self.player_chars[self.player_char_i]
 
             self.player_char_i = 0
         return self.player_chars[self.player_char_i]
 

+    def get_foo_blockers(self, foo):
+        foo_blockers = ''
+        for t in self.terrains.values():
+            block_attr = getattr(t, 'blocks_' + foo)
+            if block_attr:
+                foo_blockers += t.character
+        return foo_blockers
+
+    def get_sound_blockers(self):
+        return self.get_foo_blockers('sound')
+
+    def get_light_blockers(self):
+        return self.get_foo_blockers('light')
+
+    def get_movement_blockers(self):
+        return self.get_foo_blockers('movement')
+
+    def get_flatland(self):
+        for t in self.terrains.values():
+            if not t.blocks_movement:
+                return t.character
+

     def save(self):
 
     def save(self):
 

-      def write(f, msg):
-          f.write(msg + '\n')
-
-      with open(self.io.save_file, 'w') as f:
-          write(f, 'TURN %s' % self.turn)
-          map_geometry_shape = self.get_map_geometry_shape()
-          write(f, 'MAP %s %s' % (map_geometry_shape, self.map_geometry.size,))
-          for big_yx in [yx for yx in self.maps if self.maps[yx].modified]:
-              for y, line in self.maps[big_yx].lines():
-                  write(f, 'MAP_LINE %s %5s %s' % (big_yx, y, quote(line)))
-          for big_yx in self.annotations:
-              for little_yx in self.annotations[big_yx]:
-                  write(f, 'GOD_ANNOTATE %s %s %s' %
-                        (big_yx, little_yx, quote(self.annotations[big_yx][little_yx])))
-          for big_yx in self.portals:
-              for little_yx in self.portals[big_yx]:
-                  write(f, 'GOD_PORTAL %s %s %s' % (big_yx, little_yx,
-                                                    quote(self.portals[big_yx][little_yx])))
-          for big_yx in [yx for yx in self.map_controls
-                         if self.map_controls[yx].modified]:
-              for y, line in self.map_controls[big_yx].lines():
-                  write(f, 'MAP_CONTROL_LINE %s %5s %s' % (big_yx, y, quote(line)))
-          for tile_class in self.map_control_passwords:
-              write(f, 'MAP_CONTROL_PW %s %s' % (tile_class,
-                                                 self.map_control_passwords[tile_class]))
-          for pw in self.admin_passwords:
-                  write(f, 'ADMIN_PASSWORD %s' % pw)
-          for t in [t for t in self.things if not t.type_ == 'Player']:
-              write(f, 'THING %s %s %s %s' % (t.position[0],
-                                              t.position[1], t.type_, t.id_))
-              if hasattr(t, 'name'):
-                  write(f, 'THING_NAME %s %s' % (t.id_, quote(t.name)))
-          write(f, 'SPAWN_POINT %s %s' % (self.spawn_point[0],
-                                          self.spawn_point[1]))
+        def write(f, msg):
+            f.write(msg + '\n')
+
+        with open(self.io.save_file, 'w') as f:
+            write(f, 'TURN %s' % self.turn)
+            map_geometry_shape = self.get_map_geometry_shape()
+            write(f, 'MAP %s %s' % (map_geometry_shape, self.map_geometry.size,))
+            for terrain in self.terrains.values():
+                write(f, 'TERRAIN %s %s %s %s %s' % (quote(terrain.character),
+                                                     quote(terrain.description),
+                                                     int(terrain.blocks_light),
+                                                     int(terrain.blocks_sound),
+                                                     int(terrain.blocks_movement)))
+            for big_yx in [yx for yx in self.maps if self.maps[yx].modified]:
+                for y, line in self.maps[big_yx].lines():
+                    write(f, 'MAP_LINE %s %5s %s' % (big_yx, y, quote(line)))
+            for big_yx in self.annotations:
+                for little_yx in self.annotations[big_yx]:
+                    write(f, 'GOD_ANNOTATE %s %s %s' %
+                          (big_yx, little_yx, quote(self.annotations[big_yx][little_yx])))
+            for big_yx in self.portals:
+                for little_yx in self.portals[big_yx]:
+                    write(f, 'GOD_PORTAL %s %s %s' % (big_yx, little_yx,
+                                                      quote(self.portals[big_yx][little_yx])))
+            for big_yx in [yx for yx in self.map_controls
+                           if self.map_controls[yx].modified]:
+                for y, line in self.map_controls[big_yx].lines():
+                    write(f, 'MAP_CONTROL_LINE %s %5s %s' % (big_yx, y, quote(line)))
+            for tile_class in self.map_control_passwords:
+                write(f, 'MAP_CONTROL_PW %s %s' % (tile_class,
+                                                   self.map_control_passwords[tile_class]))
+            for pw in self.admin_passwords:
+                write(f, 'ADMIN_PASSWORD %s' % pw)
+            for name in self.faces:
+                write(f, 'GOD_PLAYER_FACE %s %s' % (quote(name),
+                                                    quote(self.faces[name])))
+            for name in self.hats:
+                write(f, 'GOD_PLAYER_HAT %s %s' % (quote(name),
+                                                   quote(self.hats[name])))
+            for t in [t for t in self.things if not t.type_ == 'Player']:
+                write(f, 'THING %s %s %s %s' % (t.position[0],
+                                                t.position[1], t.type_, t.id_))
+                write(f, 'GOD_THING_PROTECTION %s %s' % (t.id_, quote(t.protection)))
+                if hasattr(t, 'name'):
+                    write(f, 'GOD_THING_NAME %s %s' % (t.id_, quote(t.name)))
+                if hasattr(t, 'installable') and (not t.portable):
+                    write(f, 'THING_INSTALLED %s' % t.id_)
+                if t.type_ == 'Door' and t.blocking:
+                    write(f, 'THING_DOOR_CLOSED %s' % t.id_)
+                elif t.type_ == 'Hat':
+                    write(f, 'THING_HAT_DESIGN %s %s' % (t.id_,
+                                                         quote(t.design)))
+                elif t.type_ == 'MusicPlayer':
+                    write(f, 'THING_MUSICPLAYER_SETTINGS %s %s %s %s' %
+                          (t.id_, int(t.playing), t.playlist_index, int(t.repeat)))
+                    for item in t.playlist:
+                        write(f, 'THING_MUSICPLAYER_PLAYLIST_ITEM %s %s %s' %
+                              (t.id_, quote(item[0]), item[1]))
+                elif t.type_ == 'Bottle' and not t.full:
+                    write(f, 'THING_BOTTLE_EMPTY %s' % t.id_)
+            write(f, 'SPAWN_POINT %s %s' % (self.spawn_point[0],
+                                            self.spawn_point[1]))

 
     def get_map(self, big_yx, type_='normal'):
         if type_ == 'normal':
             maps = self.maps
         elif type_ == 'control':
             maps = self.map_controls
 
     def get_map(self, big_yx, type_='normal'):
         if type_ == 'normal':
             maps = self.maps
         elif type_ == 'control':
             maps = self.map_controls

-        if not big_yx in maps:
+        if big_yx not in maps:

             maps[big_yx] = SaveableMap(self.map_geometry)
             if type_ == 'control':
                 maps[big_yx].draw_presets(big_yx.y % 2)
             maps[big_yx] = SaveableMap(self.map_geometry)
             if type_ == 'control':
                 maps[big_yx].draw_presets(big_yx.y % 2)


@@ -355,9 +532,9 @@ class Game(GameBase):
         self.annotations = {}
         self.portals = {}
         self.admin_passwords = []
         self.annotations = {}
         self.portals = {}
         self.admin_passwords = []

-        self.spawn_point = YX(0,0), YX(0,0)
+        self.spawn_point = YX(0, 0), YX(0, 0)

         self.map_geometry = map_geometry
         self.map_control_passwords = {'X': 'secret'}
         self.map_geometry = map_geometry
         self.map_control_passwords = {'X': 'secret'}

-        self.get_map(YX(0,0))
-        self.get_map(YX(0,0), 'control')
+        self.get_map(YX(0, 0))
+        self.get_map(YX(0, 0), 'control')

         self.annotations = {}
         self.annotations = {}