Refactor parser code.

[plomrogue2] / plomrogue / game.py

diff --git a/plomrogue/game.py b/plomrogue/game.py
index 90f70d9937ab84d4afd0f47ea5da4e6c8893324c..cb749cffa939f38c3672945fb240ae3d6e3aef79 100755 (executable)
--- a/plomrogue/game.py
+++ b/plomrogue/game.py
@@ -2,7 +2,6 @@ from plomrogue.errors import GameError, PlayError
 from plomrogue.io import GameIO
 from plomrogue.misc import quote
 from plomrogue.mapping import YX, MapGeometrySquare, MapGeometryHex, Map
 from plomrogue.io import GameIO
 from plomrogue.misc import quote
 from plomrogue.mapping import YX, MapGeometrySquare, MapGeometryHex, Map

-import string

 import datetime
 
 
 import datetime
 
 


@@ -50,7 +49,14 @@ class SaveableMap(Map):
             return False
         return True
 
             return False
         return True
 

-    def draw_presets(self, alternate_hex=0):
+    def draw_presets(self, big_yx, type_):
+        if type_ == 1:
+            if big_yx.y < 0:
+                self.terrain = 'X' * self.size_i
+        elif type_ == 2:
+            self.draw_presets_grid(big_yx)
+
+    def draw_presets_grid(self, big_yx):

         old_modified = self.modified
         if type(self.geometry) == MapGeometrySquare:
             self.set_line(0, 'X' * self.geometry.size.x)
         old_modified = self.modified
         if type(self.geometry) == MapGeometrySquare:
             self.set_line(0, 'X' * self.geometry.size.x)


@@ -88,6 +94,7 @@ class SaveableMap(Map):
                                 if self.inside(yx):
                                     self[yx] = 'X'
 
                                 if self.inside(yx):
                                     self[yx] = 'X'
 

+                alternate_hex = big_yx.y % 2

                 if alternate_hex:
                     draw_snake(offset + YX(0, 0))
                 draw_snake(offset + YX((0 + alternate_hex) * distance,
                 if alternate_hex:
                     draw_snake(offset + YX(0, 0))
                 draw_snake(offset + YX((0 + alternate_hex) * distance,


@@ -115,6 +122,7 @@ import os
 class Game(GameBase):
 
     def __init__(self, save_file, *args, **kwargs):
 class Game(GameBase):
 
     def __init__(self, save_file, *args, **kwargs):

+        import string

         from plomrogue.misc import Terrain
         super().__init__(*args, **kwargs)
         self.changed = True
         from plomrogue.misc import Terrain
         super().__init__(*args, **kwargs)
         self.changed = True


@@ -130,8 +138,9 @@ class Game(GameBase):
         self.map_controls = {}
         self.map_control_passwords = {}
         self.annotations = {}
         self.map_controls = {}
         self.map_control_passwords = {}
         self.annotations = {}

-        self.spawn_point = YX(0, 0), YX(0, 0)
+        self.spawn_points = []

         self.portals = {}
         self.portals = {}

+        self.intro_messages = []

         self.player_chars = string.digits + string.ascii_letters
         self.players_hat_chars = {}
         self.player_char_i = -1
         self.player_chars = string.digits + string.ascii_letters
         self.players_hat_chars = {}
         self.player_char_i = -1


@@ -146,13 +155,15 @@ class Game(GameBase):
             '=': Terrain('=', 'glass', blocks_sound=True, blocks_movement=True),
             'T': Terrain('T', 'table', blocks_movement=True),
         }
             '=': Terrain('=', 'glass', blocks_sound=True, blocks_movement=True),
             'T': Terrain('T', 'table', blocks_movement=True),
         }

-        self.draw_control_presets = True
+        self.draw_control_presets = 1

         if os.path.exists(self.io.save_file):
             if not os.path.isfile(self.io.save_file):
                 raise GameError('save file path refers to non-file')
         if os.path.exists(self.io.save_file):
             if not os.path.isfile(self.io.save_file):
                 raise GameError('save file path refers to non-file')

+        self.io.train_parser()

 
     def register_thing_type(self, thing_type):
         self._register_object(thing_type, 'thing_type', 'Thing_')
 
     def register_thing_type(self, thing_type):
         self._register_object(thing_type, 'thing_type', 'Thing_')

+        self.io.train_parser()

 
     def register_task(self, task):
         self._register_object(task, 'task', 'Task_')
 
     def register_task(self, task):
         self._register_object(task, 'task', 'Task_')


@@ -181,19 +192,11 @@ class Game(GameBase):
                 return False
         return True
 
                 return False
         return True
 

-    def get_string_options(self, string_option_type):
-        if string_option_type == 'direction':
-            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 == 'map_geometry':
-            return ['Hex', 'Square']
-        elif string_option_type == 'thing_type':
-            return self.thing_types.keys()
-        return None
+    def get_default_spawn_point(self):
+        import random
+        if len(self.spawn_points) == 0:
+            return (YX(0, 0), YX(0, 0))
+        return random.choice(self.spawn_points)

 
     def get_map_geometry_shape(self):
         return self.map_geometry.__class__.__name__[len('MapGeometry'):]
 
     def get_map_geometry_shape(self):
         return self.map_geometry.__class__.__name__[len('MapGeometry'):]


@@ -334,12 +337,23 @@ class Game(GameBase):
         self.changed = True
 
     def login(self, nick, connection_id):
         self.changed = True
 
     def login(self, nick, connection_id):

+        login_limit_filename = 'login_limit'
+        if os.path.exists(login_limit_filename):
+            with open(login_limit_filename, 'r') as f:
+                lines = f.readlines()
+                login_limit = int(lines[0])
+                if len(self.sessions) > login_limit - 1:
+                    print('DEBUG LOGIN TOO MANY FOR', nick, connection_id)
+                    self.io.send('CHAT "sorry, too many users currently '
+                                 'logged in, try again later '
+                                 'by re-entering your name"', connection_id)
+                    return

         for t in [t for t in self.things
                   if t.type_ == 'Player' and t.name == nick]:
             self.io.send('GAME_ERROR ' + quote('name already in use'),
                          connection_id)
             return
         for t in [t for t in self.things
                   if t.type_ == 'Player' and t.name == nick]:
             self.io.send('GAME_ERROR ' + quote('name already in use'),
                          connection_id)
             return

-        t = self.add_thing('Player', self.spawn_point)
+        t = self.add_thing('Player', self.get_default_spawn_point())

         t.name = nick
         t.thing_char = self.get_next_player_char()
         self.sessions[connection_id] = {
         t.name = nick
         t.thing_char = self.get_next_player_char()
         self.sessions[connection_id] = {


@@ -349,6 +363,8 @@ class Game(GameBase):
         print('DEBUG LOGIN', t.name, len(self.sessions))
         self.io.send('PLAYER_ID %s' % t.id_, connection_id)
         self.io.send('LOGIN_OK', connection_id)
         print('DEBUG LOGIN', t.name, len(self.sessions))
         self.io.send('PLAYER_ID %s' % t.id_, connection_id)
         self.io.send('LOGIN_OK', connection_id)

+        for msg in self.intro_messages:
+            self.io.send('CHAT ' + quote(msg), connection_id)

         self.io.send('CHAT ' + quote(t.name + ' entered the map.'))
         for s in [s for s in self.things
                   if s.type_ == 'SpawnPoint' and s.name == t.name]:
         self.io.send('CHAT ' + quote(t.name + ' entered the map.'))
         for s in [s for s in self.things
                   if s.type_ == 'SpawnPoint' and s.name == t.name]:


@@ -356,6 +372,7 @@ class Game(GameBase):
             if s.temporary:
                 self.remove_thing(s)
                 break
             if s.temporary:
                 self.remove_thing(s)
                 break

+        t.try_to_sit()

 
     def run_tick(self):
 
 
     def run_tick(self):
 


@@ -509,7 +526,7 @@ class Game(GameBase):
             map_geometry_shape = self.get_map_geometry_shape()
             # must come before MAP, otherwise first get_map uses the default
             # TODO: refactor into MAP
             map_geometry_shape = self.get_map_geometry_shape()
             # must come before MAP, otherwise first get_map uses the default
             # TODO: refactor into MAP

-            write(f, 'MAP_CONTROL_PRESETS %s' % int(self.draw_control_presets))
+            write(f, 'MAP_CONTROL_PRESETS %s' % self.draw_control_presets)

             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),
             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),


@@ -592,8 +609,10 @@ class Game(GameBase):
                 write(f, 'THING_SPAWNPOINT_CREATED %s %s'
                       % (next_thing_id, int(datetime.datetime.now().timestamp())))
                 next_thing_id += 1
                 write(f, 'THING_SPAWNPOINT_CREATED %s %s'
                       % (next_thing_id, int(datetime.datetime.now().timestamp())))
                 next_thing_id += 1

-            write(f, 'SPAWN_POINT %s %s' % (self.spawn_point[0],
-                                            self.spawn_point[1]))
+            for s in self.spawn_points:
+                write(f, 'SPAWN_POINT %s %s' % (s[0], s[1]))
+            for msg in self.intro_messages:
+                write(f, 'INTRO_MSG %s' % quote(msg))

 
 
 
 
 
 


@@ -604,8 +623,8 @@ class Game(GameBase):
             maps = self.map_controls
         if big_yx not in maps:
             maps[big_yx] = SaveableMap(self.map_geometry)
             maps = self.map_controls
         if big_yx not in maps:
             maps[big_yx] = SaveableMap(self.map_geometry)

-            if self.draw_control_presets and type_ == 'control':
-                maps[big_yx].draw_presets(big_yx.y % 2)
+            if type_ == 'control':
+                maps[big_yx].draw_presets(big_yx, self.draw_control_presets)

         return maps[big_yx]
 
     def new_world(self, map_geometry):
         return maps[big_yx]
 
     def new_world(self, map_geometry):


@@ -614,8 +633,8 @@ 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.map_geometry = map_geometry
         self.map_geometry = map_geometry

+        self.io.train_parser()

         self.map_control_passwords = {'X': 'secret'}
         self.get_map(YX(0, 0))
         self.get_map(YX(0, 0), 'control')
         self.map_control_passwords = {'X': 'secret'}
         self.get_map(YX(0, 0))
         self.get_map(YX(0, 0), 'control')